package com.wicket.okrbff.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.wicket.okrapp.integration.*;
import com.wicket.okrapp.integration.dto.*;
import com.wicket.okrbff.biz.service.WorkTasksService;
import com.wicket.okrbff.biz.service.dto.common.*;
import com.wicket.okrbff.biz.service.dto.req.*;
import com.wicket.okrbff.biz.service.dto.res.*;
import com.wicket.okrbff.common.ro.OkrResult;
import com.wicket.okrbff.common.ro.OkrResult;
import com.wicket.okrbff.common.util.CommonFunctionHelper;
import com.wicket.okrbff.common.util.RedisUtil;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import com.wicket.okrframework.integration.FwBaseMemberClient;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.stream.Collectors;
import cn.hutool.core.collection.CollectionUtil;
import java.util.List;
import com.wicket.okrbff.common.exception.Assert;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrbff.common.exception.BizException;
import com.wicket.okrcomponent.integration.FwCompMessageClient;
import com.wicket.okrcomponent.integration.dto.ImplementIniWorkTaskMsgLocationByLoginComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementIniWorkTaskMsgLocationByLoginComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementIniProblemMsgLocationByLoginComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementIniProblemMsgLocationByLoginComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryMessageDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryMessageDetailComReqDto;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComRespDto;
import com.wicket.okrframework.integration.FwBaseSystemTestDomainClient;
import com.wicket.okrframework.integration.FwBaseOrgDictionaryClient;
import com.wicket.okrbff.common.dto.TreeNode;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class WorkTasksServiceImpl implements WorkTasksService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  FwAppWorkTasksClient fwAppWorkTasksClient;

@Resource
FwAppQuestionClient fwAppQuestionClient;

@Resource
  FwAppVirtualOrgClient fwAppVirtualOrgClient;

@Resource
  FwBaseMemberClient fwBaseMemberClient;
@Resource
  FwAppMessageClient fwAppMessageClient;
@Resource
  FwBaseInductionRecordClient fwBaseInductionRecordClient;
@Resource
  FwCompMessageClient fwCompMessageClient;
@Resource
  FwAppOfficialDocumentClient fwAppOfficialDocumentClient;
@Resource
  FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  FwAppTargetContentClient fwAppTargetContentClient;
@Resource
  FwBaseSystemTestDomainClient fwBaseSystemTestDomainClient;
@Resource
  FwAppDivineDataClient fwAppDivineDataClient;

@Resource
  FwAppInterfaceModeClient fwAppInterfaceModeClient;
@Resource
  FwBaseOrgDictionaryClient fwBaseOrgDictionaryClient;
@Resource
  FwAppCycleStageDataClient fwAppCycleStageDataClient;
@Resource
  FwAppTargetContComClient fwAppTargetContComClient;
@Resource
  FwAppCustomExecutionCycleClient fwAppCustomExecutionCycleClient;
@Resource
  FwAppDashboardWorkTaskClient fwAppDashboardWorkTaskClient;
@Resource
  FwAppEvaCalcClient fwAppEvaCalcClient;
/**
   * B3查询工作任务列表[7805]
   * gen by moon at 1/16/2024, 3:20:43 PM
   */
    @Trace(operationName = "B3查询工作任务列表")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryWorkTaskListRespDto queryWorkTaskList(BffQueryWorkTaskListReqDto reqDto){
      
       
       QueryWorkTaskListRespDto queryWorkTaskListRespDto_1 =null;
BatchQueryVirtualOrgMemberComBorderRespDto batchQueryVirtualOrgMemberComBorderRespDto_1 =null;
//步骤0: D3查询工作任务列表 - queryWorkTaskList
     QueryWorkTaskListRespDto queryWorkTaskListRespDto = null;
    QueryWorkTaskListReqDto queryWorkTaskListReqDto=new QueryWorkTaskListReqDto();
  if(reqDto!=null){
      queryWorkTaskListReqDto.setWorkTaskMgtScreen(reqDto.getWorkTaskMgtScreen());//SimpleFieldAssign//sourceId:1258573_1
queryWorkTaskListReqDto.setTaskStatusScreen(reqDto.getTaskStatusScreen());//SimpleFieldAssign//sourceId:1258574_1
queryWorkTaskListReqDto.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1421114_1
queryWorkTaskListReqDto.setTaskNumber(reqDto.getTaskNumber());//SimpleFieldAssign//sourceId:1258576_1
queryWorkTaskListReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:1258577_1
queryWorkTaskListReqDto.setPlanStartTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1258578_1
queryWorkTaskListReqDto.setPlanEndTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1258579_1
queryWorkTaskListReqDto.setSourceTypeCode(reqDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1258580_1
queryWorkTaskListReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1258587_1
queryWorkTaskListReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1391826_1
queryWorkTaskListReqDto.setIsDirectStakeholders(reqDto.getIsDirectStakeholders());//SimpleFieldAssign//sourceId:1258588_1
queryWorkTaskListReqDto.setArrangeSubjectId(reqDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1258581_1
queryWorkTaskListReqDto.setReceiveSubjectId(reqDto.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1258582_1
queryWorkTaskListReqDto.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1258583_1
queryWorkTaskListReqDto.setDeptId(reqDto.getOrgDeptId());//SimpleFieldAssign//sourceId:1368794_1
queryWorkTaskListReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1368795_1
    }
  
    /*D3查询工作任务列表[7746]   */
    Assert.isNull(queryWorkTaskListReqDto.getWorkTaskMgtScreen(),"B3查询工作任务列表-D3查询工作任务列表-工作任务管理筛选条件不能为空",false);
Assert.isNull(queryWorkTaskListReqDto.getTaskStatusScreen(),"B3查询工作任务列表-D3查询工作任务列表-工作任务状态筛选条件不能为空",false);
Assert.isNull(queryWorkTaskListReqDto.getBatchOperateScene(),"B3查询工作任务列表-D3查询工作任务列表-高/中/基层操作场景不能为空",false);
      queryWorkTaskListRespDto = fwAppWorkTasksClient.queryWorkTaskList(queryWorkTaskListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryWorkTaskListRespDto_1 = queryWorkTaskListRespDto;
    
//步骤1: D3-6批量查询虚拟组织成员(公共)(边界) - batchQueryVirtualOrgMemberComBorder
     BatchQueryVirtualOrgMemberComBorderRespDto batchQueryVirtualOrgMemberComBorderRespDto = null;
    if(queryWorkTaskListRespDto !=null){
          BatchQueryVirtualOrgMemberComBorderReqDto batchQueryVirtualOrgMemberComBorderReqDto=new BatchQueryVirtualOrgMemberComBorderReqDto();
if(queryWorkTaskListRespDto!= null&&  queryWorkTaskListRespDto.getWorkTaskList() !=null&& !CollectionUtil.isEmpty(queryWorkTaskListRespDto.getWorkTaskList())){
      batchQueryVirtualOrgMemberComBorderReqDto.setVirtualOrgMemberList(queryWorkTaskListRespDto.getWorkTaskList().stream().map(item->item.getTaskId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1258621_1
    }
  
    /*D3-6批量查询虚拟组织成员(公共)(边界)[2944]   */

      batchQueryVirtualOrgMemberComBorderRespDto = fwAppVirtualOrgClient.batchQueryVirtualOrgMemberComBorder(batchQueryVirtualOrgMemberComBorderReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      batchQueryVirtualOrgMemberComBorderRespDto_1 = batchQueryVirtualOrgMemberComBorderRespDto;
           }

//步骤2: D3执行异步更新工作内容逾期相关(公共) - implementAsyncRefreshWorkContOverdueRelateCom
     ImplementAsyncRefreshWorkContOverdueRelateComRespDto implementAsyncRefreshWorkContOverdueRelateComRespDto = null;
    if(queryWorkTaskListRespDto !=null){
          ImplementAsyncRefreshWorkContOverdueRelateComReqDto implementAsyncRefreshWorkContOverdueRelateComReqDto=new ImplementAsyncRefreshWorkContOverdueRelateComReqDto();
  implementAsyncRefreshWorkContOverdueRelateComReqDto.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1275093_1
implementAsyncRefreshWorkContOverdueRelateComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1275094_1
implementAsyncRefreshWorkContOverdueRelateComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1275095_1
if(queryWorkTaskListRespDto!= null&&  queryWorkTaskListRespDto.getWorkTaskList() !=null&& !CollectionUtil.isEmpty(queryWorkTaskListRespDto.getWorkTaskList())){
    implementAsyncRefreshWorkContOverdueRelateComReqDto.setWorkTaskObjectTypeList(//objList-to-objLists
        queryWorkTaskListRespDto.getWorkTaskList().stream().map(item -> {
      WorkTaskObjectTypeDto elm = new WorkTaskObjectTypeDto();
      elm.setWorkTaskObjectType("TASK");//sourceId:262009_2
if(item!=null){
      elm.setWorkTaskObjectId(item.getTaskId());//SimpleFieldAssign//sourceId:262010_2
elm.setSubjectLifeCycle(item.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:281472_2
elm.setOperateTime(item.getOperateTime());//SimpleFieldAssign//sourceId:262011_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1275092_1
    }

    /*D3异步更新工作任务逾期相关(公共)[7848]   */
    Assert.isNull(implementAsyncRefreshWorkContOverdueRelateComReqDto.getCreateInductionId(),"B3查询工作任务列表-D3异步更新工作任务逾期相关(公共)-创建人就职记录ID 不能为空",false);
Assert.isNull(implementAsyncRefreshWorkContOverdueRelateComReqDto.getSpaceId(),"B3查询工作任务列表-D3异步更新工作任务逾期相关(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementAsyncRefreshWorkContOverdueRelateComReqDto.getAppId(),"B3查询工作任务列表-D3异步更新工作任务逾期相关(公共)-创建于联盟应用ID不能为空",false);
      implementAsyncRefreshWorkContOverdueRelateComRespDto = fwAppWorkTasksClient.implementAsyncRefreshWorkContOverdueRelateCom(implementAsyncRefreshWorkContOverdueRelateComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤3: D3-托底更新内容状态消息数量(公共) - bottomUpdateNumberContentStatusMessagesCom
     BottomUpdateNumberContentStatusMessagesComRespDto bottomUpdateNumberContentStatusMessagesComRespDto = null;
    if(queryWorkTaskListRespDto !=null){
          BottomUpdateNumberContentStatusMessagesComReqDto bottomUpdateNumberContentStatusMessagesComReqDto=new BottomUpdateNumberContentStatusMessagesComReqDto();
  bottomUpdateNumberContentStatusMessagesComReqDto.setSceneOfUpdateStatus("SCENE_OF_WORK_TASK");//sourceId:1431444_1
bottomUpdateNumberContentStatusMessagesComReqDto.setWorkTaskObjectType("TASK");//sourceId:1431445_1
if(reqDto!=null){
      bottomUpdateNumberContentStatusMessagesComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1431439_1
bottomUpdateNumberContentStatusMessagesComReqDto.setWorkTaskMgtScreen(reqDto.getWorkTaskMgtScreen());//SimpleFieldAssign//sourceId:1431435_1
bottomUpdateNumberContentStatusMessagesComReqDto.setTaskStatusScreen(reqDto.getTaskStatusScreen());//SimpleFieldAssign//sourceId:1431436_1
bottomUpdateNumberContentStatusMessagesComReqDto.setEntityId(reqDto.getOrgDeptId());//SimpleFieldAssign//sourceId:1481850_1
    }
if(queryWorkTaskListRespDto!=null){
      bottomUpdateNumberContentStatusMessagesComReqDto.setTotals(queryWorkTaskListRespDto.getTotals());//SimpleFieldAssign//sourceId:1431446_1
    }

//    /*D3异步托底更新内容状态消息数量(公共)[8076]   */
//    Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getSceneOfUpdateStatus(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-状态更新使用场景不能为空",false);
//Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getWorkTaskObjectType(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-工作任务对象类型不能为空",false);
//Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getBatchOperateScene(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-高/中/基层操作场景不能为空",false);
//Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getWorkTaskMgtScreen(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-工作任务管理筛选条件不能为空",false);
//Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getTaskStatusScreen(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-工作任务状态筛选条件不能为空",false);
////Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getEntityId(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-归属内容ID不能为空",false);
//Assert.isNull(bottomUpdateNumberContentStatusMessagesComReqDto.getTotals(),"B3查询工作任务列表-D3异步托底更新内容状态消息数量(公共)-数据总条数不能为空",false);
//      bottomUpdateNumberContentStatusMessagesComRespDto = fwAppMessageClient.bottomUpdateNumberContentStatusMessagesCom(bottomUpdateNumberContentStatusMessagesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

BffQueryWorkTaskListRespDto retData = new BffQueryWorkTaskListRespDto();
if(queryWorkTaskListRespDto_1!=null){
      retData.setWorkTaskList(queryWorkTaskListRespDto_1.getWorkTaskList().stream().map(item -> BeanUtil.toBean(item, BffWorkTaskDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1258612_1
      retData.setTotals(queryWorkTaskListRespDto_1.getTotals());//SimpleFieldAssign//sourceId:1396320_1
    }
if(batchQueryVirtualOrgMemberComBorderRespDto_1!=null){
      retData.setVirtualOrgMemberList(batchQueryVirtualOrgMemberComBorderRespDto_1.getVirtualOrgMemberList().stream().map(item -> BeanUtil.toBean(item, BffVirtualOrgMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1258637_1
    }


  retData.setPageNum(queryWorkTaskListRespDto.getPageNum());
        retData.setPageSize(queryWorkTaskListRespDto.getPageSize());
        retData.setTotal(queryWorkTaskListRespDto.getTotalNum());
        retData.setIsLastPage((Math.ceil(Double.valueOf(queryWorkTaskListRespDto.getTotalNum()) / Double.valueOf(queryWorkTaskListRespDto.getPageSize()))) <= retData.getPageNum());
        
  
return retData;
  }
/**
   * B3新增协同任务[7753]
   * gen by moon at 12/2/2023, 4:45:48 PM
   */
    @Trace(operationName = "B3新增协同任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAddProjectRespDto addProject(BffAddProjectReqDto reqDto){
      
       
       AddProjectBusinessProcessingComRespDto addProjectBusinessProcessingComRespDto_1 =null;
//步骤0: D3-新增协同任务业务处理(公共) - addProjectBusinessProcessingCom
     AddProjectBusinessProcessingComRespDto addProjectBusinessProcessingComRespDto = null;
    AddProjectBusinessProcessingComReqDto addProjectBusinessProcessingComReqDto=new AddProjectBusinessProcessingComReqDto();
  addProjectBusinessProcessingComReqDto.setIsSystemTask("FALSE");//sourceId:1355961_1
addProjectBusinessProcessingComReqDto.setIsSystemComplete("FALSE");//sourceId:1355962_1
if(reqDto!=null){
      addProjectBusinessProcessingComReqDto.setProjectName(reqDto.getProjectName());//SimpleFieldAssign//sourceId:1276473_1
addProjectBusinessProcessingComReqDto.setProjectDesc(reqDto.getProjectDesc());//SimpleFieldAssign//sourceId:1276474_1
addProjectBusinessProcessingComReqDto.setArrangeSubjectId(reqDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1276462_1
addProjectBusinessProcessingComReqDto.setArrangeSubjectTypeCode(reqDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1276463_1
addProjectBusinessProcessingComReqDto.setReceiveSubjectId(reqDto.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1276464_1
addProjectBusinessProcessingComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1276475_1
addProjectBusinessProcessingComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1276476_1
addProjectBusinessProcessingComReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:1276477_1
addProjectBusinessProcessingComReqDto.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1276478_1
addProjectBusinessProcessingComReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1276479_1
addProjectBusinessProcessingComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1276480_1
addProjectBusinessProcessingComReqDto.setOfficialDocumentId(reqDto.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1346316_1
addProjectBusinessProcessingComReqDto.setCoordObjectTypeCode(reqDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1276465_1
addProjectBusinessProcessingComReqDto.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1276466_1
addProjectBusinessProcessingComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1276467_1
addProjectBusinessProcessingComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1276468_1
addProjectBusinessProcessingComReqDto.setSourceTypeCode(reqDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1276469_1
addProjectBusinessProcessingComReqDto.setPrincipalInductionId(reqDto.getPrincipalInductionId());//SimpleFieldAssign//sourceId:1312865_1
addProjectBusinessProcessingComReqDto.setReportObjectInductionRecordId(reqDto.getReportObjectInductionRecordId());//SimpleFieldAssign//sourceId:1276471_1
addProjectBusinessProcessingComReqDto.setMessageImportantLevel(reqDto.getMessageImportantLevel());//SimpleFieldAssign//sourceId:1357002_1
addProjectBusinessProcessingComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1276472_1
addProjectBusinessProcessingComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1366236_1
addProjectBusinessProcessingComReqDto.setBusinessOperationTypeCode(reqDto.getBusinessOperationTypeCode());//SimpleFieldAssign//sourceId:1365414_1
addProjectBusinessProcessingComReqDto.setDeptLeaderInductionRecordId(reqDto.getDeptLeaderInductionRecordId());//SimpleFieldAssign//sourceId:1366073_1
    }
  
    /*D3-新增协同任务业务处理(公共)[7852]   */
    Assert.isNull(addProjectBusinessProcessingComReqDto.getProjectName(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-项目名称不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getArrangeSubjectId(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-安排主体ID不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getArrangeSubjectTypeCode(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-安排主体类型编码不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getReceiveSubjectId(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-接收部门ID不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getCoordObjectTypeCode(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getCoordObjectId(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-归属对象ID不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getPlanStartTime(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-计划开始时间不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getPlanEndTime(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-计划结束时间不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getSourceTypeCode(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-来源类型编码不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getPrincipalInductionId(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-负责人的就职记录ID不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getReportObjectInductionRecordId(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-汇报对象就职记录ID不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getIsSystemTask(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-是否系统项目不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getIsSystemComplete(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-是否系统完成不能为空",false);
Assert.isNull(addProjectBusinessProcessingComReqDto.getSubjectLifeCycle(),"B3新增协同任务-D3-新增协同任务业务处理(公共)-主体生命周期不能为空",false);
      addProjectBusinessProcessingComRespDto = fwAppWorkTasksClient.addProjectBusinessProcessingCom(addProjectBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      addProjectBusinessProcessingComRespDto_1 = addProjectBusinessProcessingComRespDto;
    
BffAddProjectRespDto retData = new BffAddProjectRespDto();
  if(addProjectBusinessProcessingComRespDto_1!=null){
      retData.setProjectId(addProjectBusinessProcessingComRespDto_1.getProjectId());//SimpleFieldAssign//sourceId:1276834_1
    }
  

  
  
return retData;
  }
/**
   * B3新增工作任务[7756]
   * gen by moon at 6/12/2024, 6:41:26 PM
   */
    @Trace(operationName = "B3新增工作任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffAddIndependentTaskRespDto addIndependentTask(BffAddIndependentTaskReqDto reqDto){
      
       
       AddIndependentTaskBusinessProcessingComRespDto addIndependentTaskBusinessProcessingComRespDto_1 =null;
if((reqDto!= null&& reqDto.getPrincipalInductionId() != null &&reqDto!= null&&  reqDto.getPrincipalInductionIdList() !=null && reqDto.getPrincipalInductionIdList().size()==0&&reqDto!= null&& reqDto.getReceiveSubjectId() != null )) {
        //if((B3新增工作任务.负责人就职记录ID 值不等于空  and B3新增工作任务.负责人就职记录列表数据集条数 等于 0 and B3新增工作任务.接收部门ID 值不等于空 ))  68177

     AddIndependentTaskBusinessProcessingComRespDto addIndependentTaskBusinessProcessingComRespDto = null;
    AddIndependentTaskBusinessProcessingComReqDto addIndependentTaskBusinessProcessingComReqDto=new AddIndependentTaskBusinessProcessingComReqDto();
  addIndependentTaskBusinessProcessingComReqDto.setIsSystemTask("FALSE");//sourceId:1355974_1_68179
addIndependentTaskBusinessProcessingComReqDto.setIsSystemComplete("FALSE");//sourceId:1355975_1_68179
if(reqDto!=null){
      addIndependentTaskBusinessProcessingComReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:1276671_1_68179
addIndependentTaskBusinessProcessingComReqDto.setTaskNumber(reqDto.getTaskNumber());//SimpleFieldAssign//sourceId:1276672_1_68179
addIndependentTaskBusinessProcessingComReqDto.setTaskDesc(reqDto.getTaskDesc());//SimpleFieldAssign//sourceId:1276718_1_68179
addIndependentTaskBusinessProcessingComReqDto.setTaskType(reqDto.getTaskType());//SimpleFieldAssign//sourceId:1276673_1_68179
addIndependentTaskBusinessProcessingComReqDto.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1396418_1_68179
addIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectId(reqDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1276674_1_68179
addIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectTypeCode(reqDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1276675_1_68179
addIndependentTaskBusinessProcessingComReqDto.setReceiveSubjectId(reqDto.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1276676_1_68179
addIndependentTaskBusinessProcessingComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1276677_1_68179
addIndependentTaskBusinessProcessingComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1276678_1_68179
addIndependentTaskBusinessProcessingComReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:1276679_1_68179
addIndependentTaskBusinessProcessingComReqDto.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1276680_1_68179
addIndependentTaskBusinessProcessingComReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1276681_1_68179
addIndependentTaskBusinessProcessingComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1276682_1_68179
addIndependentTaskBusinessProcessingComReqDto.setOfficialDocumentId(reqDto.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1346324_1_68179
addIndependentTaskBusinessProcessingComReqDto.setCoordObjectTypeCode(reqDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1276683_1_68179
addIndependentTaskBusinessProcessingComReqDto.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1276684_1_68179
addIndependentTaskBusinessProcessingComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797957_1_68179
addIndependentTaskBusinessProcessingComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1276685_1_68179
addIndependentTaskBusinessProcessingComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1276686_1_68179
addIndependentTaskBusinessProcessingComReqDto.setSourceTypeCode(reqDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1276687_1_68179
addIndependentTaskBusinessProcessingComReqDto.setPrincipalInductionId(reqDto.getPrincipalInductionId());//SimpleFieldAssign//sourceId:1312846_1_68179
addIndependentTaskBusinessProcessingComReqDto.setReportObjectInductionRecordId(reqDto.getReportObjectInductionRecordId());//SimpleFieldAssign//sourceId:1276689_1_68179
addIndependentTaskBusinessProcessingComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1276690_1_68179
addIndependentTaskBusinessProcessingComReqDto.setMessageImportantLevel(reqDto.getMessageImportantLevel());//SimpleFieldAssign//sourceId:1357012_1_68179
addIndependentTaskBusinessProcessingComReqDto.setBusinessOperationTypeCode(reqDto.getBusinessOperationTypeCode());//SimpleFieldAssign//sourceId:1365396_1_68179
addIndependentTaskBusinessProcessingComReqDto.setDeptLeaderInductionRecordId(reqDto.getDeptLeaderInductionRecordId());//SimpleFieldAssign//sourceId:1366082_1_68179
addIndependentTaskBusinessProcessingComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1423330_1_68179
    }
  
    /*D3-新增独立任务（或子任务）业务处理(公共)[7853]   */
    Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskName(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-任务名称不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskType(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-任务类型不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getWorkTaskType(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-工作任务类别不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectId(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-安排主体ID不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectTypeCode(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-安排主体类型编码不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getCoordObjectTypeCode(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getCoordObjectId(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-归属对象ID不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getPlanStartTime(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-计划开始时间不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getPlanEndTime(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-计划结束时间不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getSourceTypeCode(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-来源类型编码不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getReportObjectInductionRecordId(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-汇报对象就职记录ID不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getIsSystemTask(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-是否系统任务不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getIsSystemComplete(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-是否系统完成不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getSubjectLifeCycle(),"B3新增工作任务-D3-新增独立任务（或子任务）业务处理(公共)-主体生命周期不能为空",false);
      addIndependentTaskBusinessProcessingComRespDto = fwAppWorkTasksClient.addIndependentTaskBusinessProcessingCom(addIndependentTaskBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      addIndependentTaskBusinessProcessingComRespDto_1 = addIndependentTaskBusinessProcessingComRespDto;
      }
else if((reqDto!= null&& reqDto.getPrincipalInductionId() == null &&reqDto!= null&&  reqDto.getPrincipalInductionIdList() !=null && reqDto.getPrincipalInductionIdList().size()>0)){
       //elseif((B3新增工作任务.负责人就职记录ID 值等于空  and B3新增工作任务.负责人就职记录列表数据集条数 大于 0))  68178

BatchAddIndependentTaskBusinessProcessingComRespDto batchAddIndependentTaskBusinessProcessingComRespDto = null;
    BatchAddIndependentTaskBusinessProcessingComReqDto batchAddIndependentTaskBusinessProcessingComReqDto=new BatchAddIndependentTaskBusinessProcessingComReqDto();
  batchAddIndependentTaskBusinessProcessingComReqDto.setIsSystemTask("FALSE");//sourceId:1786916_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setIsSystemComplete("FALSE");//sourceId:1786917_1_68180
if(reqDto!= null&&  reqDto.getPrincipalInductionIdList() !=null&& !CollectionUtil.isEmpty(reqDto.getPrincipalInductionIdList())){
      batchAddIndependentTaskBusinessProcessingComReqDto.setPrincipalInductionIdList(reqDto.getPrincipalInductionIdList().stream().map(item -> BeanUtil.toBean(item, PrincipalInductionIdDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1786924_1_68180
    }
if(reqDto!=null){
      batchAddIndependentTaskBusinessProcessingComReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:1786896_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setTaskNumber(reqDto.getTaskNumber());//SimpleFieldAssign//sourceId:1786897_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setTaskDesc(reqDto.getTaskDesc());//SimpleFieldAssign//sourceId:1786898_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setTaskType(reqDto.getTaskType());//SimpleFieldAssign//sourceId:1786899_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1786900_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectId(reqDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1786901_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectTypeCode(reqDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1786902_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1786904_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1786905_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:1786906_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1786907_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1786908_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1786909_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setOfficialDocumentId(reqDto.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1786910_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setCoordObjectTypeCode(reqDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1786911_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1786912_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1797990_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1786913_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1786914_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setSourceTypeCode(reqDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1786915_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1786918_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setMessageImportantLevel(reqDto.getMessageImportantLevel());//SimpleFieldAssign//sourceId:1786919_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setBusinessOperationTypeCode(reqDto.getBusinessOperationTypeCode());//SimpleFieldAssign//sourceId:1786920_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setReportObjectInductionRecordId(reqDto.getReportObjectInductionRecordId());//SimpleFieldAssign//sourceId:1786921_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setDeptLeaderInductionRecordId(reqDto.getDeptLeaderInductionRecordId());//SimpleFieldAssign//sourceId:1786922_1_68180
batchAddIndependentTaskBusinessProcessingComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1786923_1_68180
    }

    /*D3批量增独立任务业务处理(公共)[9531]   */
    Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getTaskName(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-任务名称不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getTaskType(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-任务类型不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectId(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-安排主体ID不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectTypeCode(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-安排主体类型编码不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getCoordObjectTypeCode(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-归属对象类型编码不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getCoordObjectId(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-归属对象ID不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getPlanStartTime(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-计划开始时间不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getPlanEndTime(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-计划结束时间不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getSourceTypeCode(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-来源类型编码不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getIsSystemTask(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-是否系统任务不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getSubjectLifeCycle(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-主体生命周期不能为空",false);
Assert.isNull(batchAddIndependentTaskBusinessProcessingComReqDto.getReportObjectInductionRecordId(),"B3新增工作任务-D3批量增独立任务业务处理(公共)-汇报对象就职记录ID不能为空",false);
      batchAddIndependentTaskBusinessProcessingComRespDto = fwAppWorkTasksClient.batchAddIndependentTaskBusinessProcessingCom(batchAddIndependentTaskBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



    }
else if((reqDto!= null&& reqDto.getPrincipalInductionId() != null &&reqDto!= null&&  reqDto.getPrincipalInductionIdList() !=null && reqDto.getPrincipalInductionIdList().size()==0&&reqDto!= null&& reqDto.getReceiveSubjectId() == null )){
       //elseif((B3新增工作任务.负责人就职记录ID 值不等于空  and B3新增工作任务.负责人就职记录列表数据集条数 等于 0 and B3新增工作任务.接收部门ID 值等于空 ))  69914

//异常结束 69915
      throw new BizException("3P10100452","对不起，新增工作任务未选择接收部门ID~",false);
    }
BffAddIndependentTaskRespDto retData = new BffAddIndependentTaskRespDto();
  if(addIndependentTaskBusinessProcessingComRespDto_1!=null){
      retData.setTaskId(addIndependentTaskBusinessProcessingComRespDto_1.getTaskId());//SimpleFieldAssign//sourceId:1276864_1
    }
  

  
  
return retData;
  }
/**
   * B3查询协同任务详情[7768]
   * gen by moon at 12/6/2023, 7:53:39 PM
   */
    @Trace(operationName = "B3查询协同任务详情")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryProjectDetailRespDto queryProjectDetail(BffQueryProjectDetailReqDto reqDto){
      
       
       QueryProjectDetailComRespDto queryProjectDetailComRespDto_1 =null;
ImplementContentStateConversionComRespDto implementContentStateConversionComRespDto_1 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
QueryMessageDetailComRespDto queryMessageDetailComRespDto_1 =null;
QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto_1 =null;
ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_1 =null;
QueryOfficialDocumentDetailComRespDto queryOfficialDocumentDetailComRespDto_1 =null;
ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_3 =null;
ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_6 =null;
//virtualUsage D3查询协同任务详情(公共)  52395
     QueryProjectDetailComRespDto queryProjectDetailComRespDto = null;
    QueryProjectDetailComReqDto queryProjectDetailComReqDto=new QueryProjectDetailComReqDto();
  queryProjectDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1264445_1_52395
if(reqDto!=null){
      queryProjectDetailComReqDto.setProjectId(reqDto.getProjectId());//SimpleFieldAssign//sourceId:1255257_1_52395
    }
  
    /*D3查询协同任务详情(公共)[7767]   */
    Assert.isNull(queryProjectDetailComReqDto.getProjectId(),"B3查询协同任务详情-D3查询协同任务详情(公共)-项目ID不能为空",false);
    Assert.isNull(queryProjectDetailComReqDto.getSpaceId(),"B3查询协同任务详情-D3查询协同任务详情(公共)-创建于空间ID不能为空",false);
      queryProjectDetailComRespDto = fwAppWorkTasksClient.queryProjectDetailCom(queryProjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryProjectDetailComRespDto== null||  queryProjectDetailComRespDto.getOperationInductionId() ==null,"找不到数据，系统异常",false);
      
      queryProjectDetailComRespDto_1 = queryProjectDetailComRespDto;
//virtualUsage D3执行内容状态转换(公共)  54833
      ImplementContentStateConversionComRespDto implementContentStateConversionComRespDto = null;
    if(queryProjectDetailComRespDto !=null){
          ImplementContentStateConversionComReqDto implementContentStateConversionComReqDto=new ImplementContentStateConversionComReqDto();
  implementContentStateConversionComReqDto.setWorkTaskObjectType("PROJECT");//sourceId:1361917_1_54833
if(reqDto!=null){
      implementContentStateConversionComReqDto.setTaskStatusScreen(reqDto.getTaskStatusScreen());//SimpleFieldAssign//sourceId:1391760_1_54833
      implementContentStateConversionComReqDto.setWorkTaskObjectId(reqDto.getProjectId());//SimpleFieldAssign//sourceId:1361922_1_54833
    }
if(queryProjectDetailComRespDto!=null){
      implementContentStateConversionComReqDto.setTaskStatus(queryProjectDetailComRespDto.getTaskStatus());//SimpleFieldAssign//sourceId:1361918_1_54833
implementContentStateConversionComReqDto.setIsComplete(queryProjectDetailComRespDto.getIsComplete());//SimpleFieldAssign//sourceId:1361919_1_54833
implementContentStateConversionComReqDto.setIsOverdue(queryProjectDetailComRespDto.getIsOverdue());//SimpleFieldAssign//sourceId:1361920_1_54833
implementContentStateConversionComReqDto.setSubjectLifeCycle(queryProjectDetailComRespDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1361921_1_54833
    }

    /*D3执行内容状态转换(公共)[8037]   */
    Assert.isNull(implementContentStateConversionComReqDto.getWorkTaskObjectType(),"B3查询协同任务详情-D3执行内容状态转换(公共)-工作任务对象类型不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getWorkTaskObjectId(),"B3查询协同任务详情-D3执行内容状态转换(公共)-工作任务对象ID不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getTaskStatus(),"B3查询协同任务详情-D3执行内容状态转换(公共)-任务进展状态不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getIsComplete(),"B3查询协同任务详情-D3执行内容状态转换(公共)-是否完成不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getIsOverdue(),"B3查询协同任务详情-D3执行内容状态转换(公共)-是否逾期不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getSubjectLifeCycle(),"B3查询协同任务详情-D3执行内容状态转换(公共)-主体生命周期不能为空",false);
      implementContentStateConversionComRespDto = fwAppWorkTasksClient.implementContentStateConversionCom(implementContentStateConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementContentStateConversionComRespDto_1 = implementContentStateConversionComRespDto;
           }
//virtualUsage D2查来源名称  54641
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(queryProjectDetailComRespDto !=null){
          com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1354094_1_54641
queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:1354095_1_54641
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("WROK_TASK_SOURCE_CONF");//CUSTOM_CONVENTION//sourceId:1354096_1_54641
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1354098_1_54641
if(queryProjectDetailComRespDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfOptionCode(queryProjectDetailComRespDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1354097_1_54641
    }

    /*D2查来源名称[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfOptionCode(),"B3查询协同任务详情-D2查来源名称-选项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"B3查询协同任务详情-D2查来源名称-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"B3查询协同任务详情-D2查来源名称-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"B3查询协同任务详情-D2查来源名称-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"B3查询协同任务详情-D2查来源名称-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
           }
//virtualUsage D2查项目签收状态  54464
      QueryMessageDetailComRespDto queryMessageDetailComRespDto = null;
    if(queryProjectDetailComRespDto !=null){
          QueryMessageDetailComReqDto queryMessageDetailComReqDto=new QueryMessageDetailComReqDto();
  queryMessageDetailComReqDto.setBehaviorTypeCode("GENERATE_TO_BE_SIGNED_WORK_TASK_MSG_TEMP");//CUSTOM_CONVENTION//sourceId:1346471_1_54464
queryMessageDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1346472_1_54464
if(queryProjectDetailComRespDto!=null){
      queryMessageDetailComReqDto.setEntityId(queryProjectDetailComRespDto.getProjectId());//SimpleFieldAssign//sourceId:1346470_1_54464
    }

    /*D2查项目签收状态[7526]   */
    Assert.isNull(queryMessageDetailComReqDto.getEntityId(),"B3查询协同任务详情-D2查项目签收状态-归属内容ID不能为空",false);
Assert.isNull(queryMessageDetailComReqDto.getBehaviorTypeCode(),"B3查询协同任务详情-D2查项目签收状态-行为类型编码不能为空",false);
Assert.isNull(queryMessageDetailComReqDto.getSpaceId(),"B3查询协同任务详情-D2查项目签收状态-创建于空间ID不能为空",false);
      queryMessageDetailComRespDto = fwCompMessageClient.queryMessageDetailCom(queryMessageDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryMessageDetailComRespDto_1 = queryMessageDetailComRespDto;
           }
//virtualUsage D1-3查询个人就职记录信息详情（公共）  52407
     QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
    if(queryProjectDetailComRespDto !=null){
          QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto=new QueryInductionRecordInfoDetailComReqDto();
  if(queryProjectDetailComRespDto!=null){
      queryInductionRecordInfoDetailComReqDto.setInductionRecordId(queryProjectDetailComRespDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1255674_1_52407
    }
  
    /*D1-3查询个人就职记录信息详情（公共）[715]   */

      queryInductionRecordInfoDetailComRespDto = fwBaseInductionRecordClient.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryInductionRecordInfoDetailComRespDto_1 = queryInductionRecordInfoDetailComRespDto;
           }
//virtualUsage D3获取接收部门名称(公共)  52655
      ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto = null;
    if(queryProjectDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto=new ObtainMainBodyObjectComReqDto();
  obtainMainBodyObjectComReqDto.setTableTypeCode("OMS_ORG_DEPT");//sourceId:1279862_1_52655
if(queryProjectDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto.setEntityId(queryProjectDetailComRespDto.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1279863_1_52655
    }

    /*D3获取接收部门名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto.getTableTypeCode(),"B3查询协同任务详情-D3获取接收部门名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto.getEntityId(),"B3查询协同任务详情-D3获取接收部门名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_1 = obtainMainBodyObjectComRespDto;
           }
if((queryProjectDetailComRespDto!= null&&  queryProjectDetailComRespDto.getSourceTypeCode() !=null && queryProjectDetailComRespDto.getSourceTypeCode().equals("DOCUMENT_TASKS"))) {
        //if(D3查询协同任务详情(公共).来源类型编码 等于 公文任务)  54427

QueryOfficialDocumentDetailComRespDto queryOfficialDocumentDetailComRespDto = null;
    if(queryProjectDetailComRespDto !=null){
          QueryOfficialDocumentDetailComReqDto queryOfficialDocumentDetailComReqDto=new QueryOfficialDocumentDetailComReqDto();
  queryOfficialDocumentDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1345999_1_54428
if(queryProjectDetailComRespDto!=null){
      queryOfficialDocumentDetailComReqDto.setArrangeWorkTaskId(queryProjectDetailComRespDto.getProjectId());//SimpleFieldAssign//sourceId:1346025_1_54428
    }

    /*D3-9查关联的公文信息(公共)[7930]   */
    Assert.isNull(queryOfficialDocumentDetailComReqDto.getArrangeWorkTaskId(),"B3查询协同任务详情-D3-9查关联的公文信息(公共)-安排的工作任务ID不能为空",false);
Assert.isNull(queryOfficialDocumentDetailComReqDto.getSpaceId(),"B3查询协同任务详情-D3-9查关联的公文信息(公共)-创建于空间ID不能为空",false);
      queryOfficialDocumentDetailComRespDto = fwAppOfficialDocumentClient.queryOfficialDocumentDetailCom(queryOfficialDocumentDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryOfficialDocumentDetailComRespDto_1 = queryOfficialDocumentDetailComRespDto;
           }
      }
if((queryProjectDetailComRespDto!= null&&  queryProjectDetailComRespDto.getArrangeSubjectTypeCode() !=null && queryProjectDetailComRespDto.getArrangeSubjectTypeCode().equals("OMS_ORG_ORGANIZATION"))) {
        //if(D3查询协同任务详情(公共).安排主体类型编码 等于 组织表)  52397

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_2 = null;
    if(queryProjectDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_1=new ObtainMainBodyObjectComReqDto();
  if(queryProjectDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_1.setTableTypeCode(queryProjectDetailComRespDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1279835_1_52648
obtainMainBodyObjectComReqDto_1.setEntityId(queryProjectDetailComRespDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1279836_1_52648
    }

    /*D3获取安排主体对象名称[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_1.getTableTypeCode(),"B3查询协同任务详情-D3获取安排主体对象名称-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_1.getEntityId(),"B3查询协同任务详情-D3获取安排主体对象名称-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_2 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_3 = obtainMainBodyObjectComRespDto_2;
           }
      }
else if((queryProjectDetailComRespDto!= null&&  queryProjectDetailComRespDto.getArrangeSubjectTypeCode() !=null && queryProjectDetailComRespDto.getArrangeSubjectTypeCode().equals("OMS_ORG_DEPT"))){
       //elseif(D3查询协同任务详情(公共).安排主体类型编码 等于 部门表)  52398

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_4 = null;
    if(queryProjectDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_2=new ObtainMainBodyObjectComReqDto();
  if(queryProjectDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_2.setTableTypeCode(queryProjectDetailComRespDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1279835_1_52652
obtainMainBodyObjectComReqDto_2.setEntityId(queryProjectDetailComRespDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1279836_1_52652
           }
    
    /*D3获取安排主体对象名称[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_2.getTableTypeCode(),"B3查询协同任务详情-D3获取安排主体对象名称-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_2.getEntityId(),"B3查询协同任务详情-D3获取安排主体对象名称-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_4 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_3 = obtainMainBodyObjectComRespDto_4;
           }
    }
else{
       //else  52401

//异常结束 52402
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
if((queryProjectDetailComRespDto!= null&&  queryProjectDetailComRespDto.getCoordObjectTypeCode() !=null && queryProjectDetailComRespDto.getCoordObjectTypeCode().equals("OMS_ORG_DEPT"))) {
        //if(D3查询协同任务详情(公共).归属对象类型编码 等于 部门表)  52400

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_5 = null;
    if(queryProjectDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_3=new ObtainMainBodyObjectComReqDto();
  if(queryProjectDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_3.setTableTypeCode(queryProjectDetailComRespDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1279839_1_52653
obtainMainBodyObjectComReqDto_3.setEntityId(queryProjectDetailComRespDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1279840_1_52653
    }

    /*D3获取归属对象名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_3.getTableTypeCode(),"B3查询协同任务详情-D3获取归属对象名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_3.getEntityId(),"B3查询协同任务详情-D3获取归属对象名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_5 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_6 = obtainMainBodyObjectComRespDto_5;
           }
      }
else if((queryProjectDetailComRespDto!= null&&  queryProjectDetailComRespDto.getCoordObjectTypeCode() !=null && queryProjectDetailComRespDto.getCoordObjectTypeCode().equals("OMS_FRAMEWORK_SPACE"))){
       //elseif(D3查询协同任务详情(公共).归属对象类型编码 等于 空间表)  52403

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_7 = null;
    if(queryProjectDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_4=new ObtainMainBodyObjectComReqDto();
  if(queryProjectDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_4.setTableTypeCode(queryProjectDetailComRespDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1279839_1_52654
obtainMainBodyObjectComReqDto_4.setEntityId(queryProjectDetailComRespDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1279840_1_52654
    }

    /*D3获取归属对象名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_4.getTableTypeCode(),"B3查询协同任务详情-D3获取归属对象名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_4.getEntityId(),"B3查询协同任务详情-D3获取归属对象名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_7 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_6 = obtainMainBodyObjectComRespDto_7;
           }
    }
else{
       //else  52405

//异常结束 52406
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
BffQueryProjectDetailRespDto retData = new BffQueryProjectDetailRespDto();
  if(queryProjectDetailComRespDto_1!=null){
      retData.setProjectId(queryProjectDetailComRespDto_1.getProjectId());//SimpleFieldAssign//sourceId:1264448_1
retData.setProjectNumber(queryProjectDetailComRespDto_1.getProjectNumber());//SimpleFieldAssign//sourceId:1264449_1
retData.setProjectCode(queryProjectDetailComRespDto_1.getProjectCode());//SimpleFieldAssign//sourceId:1264450_1
retData.setProjectName(queryProjectDetailComRespDto_1.getProjectName());//SimpleFieldAssign//sourceId:1264451_1
retData.setProjectLogo(queryProjectDetailComRespDto_1.getProjectLogo());//SimpleFieldAssign//sourceId:1264452_1
retData.setProjectDesc(queryProjectDetailComRespDto_1.getProjectDesc());//SimpleFieldAssign//sourceId:1264453_1
retData.setProjectImg(queryProjectDetailComRespDto_1.getProjectImg());//SimpleFieldAssign//sourceId:1264454_1
retData.setArrangeSubjectId(queryProjectDetailComRespDto_1.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1264455_1
retData.setReceiveSubjectId(queryProjectDetailComRespDto_1.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1264456_1
retData.setCoordObjectId(queryProjectDetailComRespDto_1.getCoordObjectId());//SimpleFieldAssign//sourceId:1264457_1
retData.setPlanStartTime(queryProjectDetailComRespDto_1.getPlanStartTime());//SimpleFieldAssign//sourceId:1264458_1
retData.setPlanEndTime(queryProjectDetailComRespDto_1.getPlanEndTime());//SimpleFieldAssign//sourceId:1264459_1
retData.setActualStartTime(queryProjectDetailComRespDto_1.getActualStartTime());//SimpleFieldAssign//sourceId:1264460_1
retData.setActualEndTime(queryProjectDetailComRespDto_1.getActualEndTime());//SimpleFieldAssign//sourceId:1264461_1
retData.setTotalLength(queryProjectDetailComRespDto_1.getTotalLength());//SimpleFieldAssign//sourceId:1264462_1
retData.setDeflectionStartDays(queryProjectDetailComRespDto_1.getDeflectionStartDays());//SimpleFieldAssign//sourceId:1264463_1
retData.setDeflectionEndDays(queryProjectDetailComRespDto_1.getDeflectionEndDays());//SimpleFieldAssign//sourceId:1264464_1
retData.setDeflectionTime(queryProjectDetailComRespDto_1.getDeflectionTime());//SimpleFieldAssign//sourceId:1264465_1
retData.setDeflectionInfo(queryProjectDetailComRespDto_1.getDeflectionInfo());//SimpleFieldAssign//sourceId:1264466_1
retData.setPercentageProgress(queryProjectDetailComRespDto_1.getPercentageProgress());//SimpleFieldAssign//sourceId:1264467_1
retData.setProjectScale(queryProjectDetailComRespDto_1.getProjectScale());//SimpleFieldAssign//sourceId:1264468_1
retData.setProjectPriority(queryProjectDetailComRespDto_1.getProjectPriority());//SimpleFieldAssign//sourceId:1264469_1
retData.setProjectTypeCode(queryProjectDetailComRespDto_1.getProjectTypeCode());//SimpleFieldAssign//sourceId:1264470_1
retData.setSourceTypeCode(queryProjectDetailComRespDto_1.getSourceTypeCode());//SimpleFieldAssign//sourceId:1264471_1
retData.setMembershipIsLockedRevise(queryProjectDetailComRespDto_1.getMembershipIsLockedRevise());//SimpleFieldAssign//sourceId:1269199_1
retData.setRelevantPeopleNum(queryProjectDetailComRespDto_1.getRelevantPeopleNum());//SimpleFieldAssign//sourceId:1264476_1
retData.setTaskStatus(queryProjectDetailComRespDto_1.getTaskStatus());//SimpleFieldAssign//sourceId:1264472_1
retData.setIsSystemTask(queryProjectDetailComRespDto_1.getIsSystemTask());//SimpleFieldAssign//sourceId:1354147_1
retData.setSubjectLifeCycle(queryProjectDetailComRespDto_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1264477_1
retData.setOperationInductionId(queryProjectDetailComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1264478_1
retData.setOperateTime(queryProjectDetailComRespDto_1.getOperateTime());//SimpleFieldAssign//sourceId:1264479_1
    }
if(obtainMainBodyObjectComRespDto_3!=null){
      retData.setArrangeSubjectName(obtainMainBodyObjectComRespDto_3.getObjectName());//SimpleFieldAssign//sourceId:1279860_1
    }
if(obtainMainBodyObjectComRespDto_1!=null){
      retData.setReceiveSubjectName(obtainMainBodyObjectComRespDto_1.getObjectName());//SimpleFieldAssign//sourceId:1279866_1
    }
if(obtainMainBodyObjectComRespDto_6!=null){
      retData.setCoordObjectName(obtainMainBodyObjectComRespDto_6.getObjectName());//SimpleFieldAssign//sourceId:1279861_1
    }
if(queryOfficialDocumentDetailComRespDto_1!=null){
      retData.setOfficialDocumentId(queryOfficialDocumentDetailComRespDto_1.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1346028_1
retData.setOfficialDocumentName(queryOfficialDocumentDetailComRespDto_1.getOfficialDocumentName());//SimpleFieldAssign//sourceId:1346029_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setSourceName(queryConfItemMatchAnswerDetailComRespDto_1.getExtensionField2());//SimpleFieldAssign//sourceId:1355940_1
    }
if(implementContentStateConversionComRespDto_1!=null){
      retData.setStateCode(implementContentStateConversionComRespDto_1.getStateCode());//SimpleFieldAssign//sourceId:1391759_1
    }
if(queryMessageDetailComRespDto_1!=null){
      retData.setIsHandle(queryMessageDetailComRespDto_1.getIsHandle());//SimpleFieldAssign//sourceId:1346474_1
    }
if(queryInductionRecordInfoDetailComRespDto_1!=null){
      retData.setUserId(queryInductionRecordInfoDetailComRespDto_1.getUserId());//SimpleFieldAssign//sourceId:1269992_1
retData.setUserFace(queryInductionRecordInfoDetailComRespDto_1.getUserFace());//SimpleFieldAssign//sourceId:1269995_1
retData.setIdCardName(queryInductionRecordInfoDetailComRespDto_1.getIdCardName());//SimpleFieldAssign//sourceId:1269993_1
retData.setNickName(queryInductionRecordInfoDetailComRespDto_1.getNickName());//SimpleFieldAssign//sourceId:1269994_1
    }


  
  
return retData;
  }
/**
   * B3删除协同任务[7771]
   * gen by moon at 11/10/2023, 3:57:18 PM
   */
    @Trace(operationName = "B3删除协同任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffDeleteProjectRespDto deleteProject(BffDeleteProjectReqDto reqDto){
      
       
       //步骤0: D3删除协同任务业务处理(公共) - deleteProjectBusinessProcessingCom
     DeleteProjectBusinessProcessingComRespDto deleteProjectBusinessProcessingComRespDto = null;
    DeleteProjectBusinessProcessingComReqDto deleteProjectBusinessProcessingComReqDto=new DeleteProjectBusinessProcessingComReqDto();
  if(reqDto!=null){
      deleteProjectBusinessProcessingComReqDto.setProjectId(reqDto.getProjectId());//SimpleFieldAssign//sourceId:1280121_1
    }
  
    /*D3删除协同任务业务处理(公共)[7862]   */
    Assert.isNull(deleteProjectBusinessProcessingComReqDto.getProjectId(),"B3删除协同任务-D3删除协同任务业务处理(公共)-项目ID不能为空",false);
      deleteProjectBusinessProcessingComRespDto = fwAppWorkTasksClient.deleteProjectBusinessProcessingCom(deleteProjectBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffDeleteProjectRespDto retData = new BffDeleteProjectRespDto();
  
  

  
  
return retData;
  }
/**
   * B3存档协同任务[7775]
   * gen by moon at 11/8/2023, 4:24:11 PM
   */
    @Trace(operationName = "B3存档协同任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffArchiveProjectRespDto archiveProject(BffArchiveProjectReqDto reqDto){
      
       
       //步骤0: D3存档协同任务 - archiveProject
     ArchiveProjectRespDto archiveProjectRespDto = null;
    ArchiveProjectReqDto archiveProjectReqDto=new ArchiveProjectReqDto();
  if(reqDto!=null){
      archiveProjectReqDto.setProjectId(reqDto.getProjectId());//SimpleFieldAssign//sourceId:1263696_1
archiveProjectReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1264665_1
archiveProjectReqDto.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1264666_1
    }
  
    /*D3存档协同任务[7774]   */
    Assert.isNull(archiveProjectReqDto.getProjectId(),"B3存档协同任务-D3存档协同任务-项目ID不能为空",false);
Assert.isNull(archiveProjectReqDto.getSubjectLifeCycle(),"B3存档协同任务-D3存档协同任务-主体生命周期不能为空",false);
Assert.isNull(archiveProjectReqDto.getIsArchive(),"B3存档协同任务-D3存档协同任务-是否存档不能为空",false);
      archiveProjectRespDto = fwAppWorkTasksClient.archiveProject(archiveProjectReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffArchiveProjectRespDto retData = new BffArchiveProjectRespDto();
  
  

  
  
return retData;
  }
/**
   * B3修改协同任务[7777]
   * gen by moon at 12/2/2023, 4:45:55 PM
   */
    @Trace(operationName = "B3修改协同任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateProjectRespDto updateProject(BffUpdateProjectReqDto reqDto){
      
       
       //步骤0: D3修改协同任务业务处理(公共) - updateProjectBusinessProcessingCom
     UpdateProjectBusinessProcessingComRespDto updateProjectBusinessProcessingComRespDto = null;
    UpdateProjectBusinessProcessingComReqDto updateProjectBusinessProcessingComReqDto=new UpdateProjectBusinessProcessingComReqDto();
  if(reqDto!=null){
      updateProjectBusinessProcessingComReqDto.setProjectId(reqDto.getProjectId());//SimpleFieldAssign//sourceId:1277893_1
updateProjectBusinessProcessingComReqDto.setProjectNumber(reqDto.getProjectNumber());//SimpleFieldAssign//sourceId:1277894_1
updateProjectBusinessProcessingComReqDto.setProjectName(reqDto.getProjectName());//SimpleFieldAssign//sourceId:1277895_1
updateProjectBusinessProcessingComReqDto.setProjectLogo(reqDto.getProjectLogo());//SimpleFieldAssign//sourceId:1277896_1
updateProjectBusinessProcessingComReqDto.setProjectDesc(reqDto.getProjectDesc());//SimpleFieldAssign//sourceId:1277897_1
updateProjectBusinessProcessingComReqDto.setProjectImg(reqDto.getProjectImg());//SimpleFieldAssign//sourceId:1277898_1
updateProjectBusinessProcessingComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1277899_1
updateProjectBusinessProcessingComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1277900_1
updateProjectBusinessProcessingComReqDto.setOfficialDocumentId(reqDto.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1346408_1
updateProjectBusinessProcessingComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1277901_1
updateProjectBusinessProcessingComReqDto.setMessageImportantLevel(reqDto.getMessageImportantLevel());//SimpleFieldAssign//sourceId:1357022_1
updateProjectBusinessProcessingComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1366244_1
updateProjectBusinessProcessingComReqDto.setBusinessOperationTypeCode(reqDto.getBusinessOperationTypeCode());//SimpleFieldAssign//sourceId:1365441_1
updateProjectBusinessProcessingComReqDto.setDeptLeaderInductionRecordId(reqDto.getDeptLeaderInductionRecordId());//SimpleFieldAssign//sourceId:1366059_1
    }
  
    /*D3修改协同任务业务处理(公共)[7855]   */
    Assert.isNull(updateProjectBusinessProcessingComReqDto.getProjectId(),"B3修改协同任务-D3修改协同任务业务处理(公共)-项目ID不能为空",false);
      updateProjectBusinessProcessingComRespDto = fwAppWorkTasksClient.updateProjectBusinessProcessingCom(updateProjectBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffUpdateProjectRespDto retData = new BffUpdateProjectRespDto();
  
  

  
  
return retData;
  }
/**
   * B3修改独立任务或子任务[7779]
   * gen by moon at 9/5/2024, 10:17:50 PM
   */
    @Trace(operationName = "B3修改独立任务或子任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffUpdateIndependentTaskRespDto updateIndependentTask(BffUpdateIndependentTaskReqDto reqDto){
      
       
       //步骤0: D3修改独立任务（或子任务）业务处理(公共) - updateIndependentTaskBusinessProcessingCom
     UpdateIndependentTaskBusinessProcessingComRespDto updateIndependentTaskBusinessProcessingComRespDto = null;
    UpdateIndependentTaskBusinessProcessingComReqDto updateIndependentTaskBusinessProcessingComReqDto=new UpdateIndependentTaskBusinessProcessingComReqDto();
  if(reqDto!=null){
      updateIndependentTaskBusinessProcessingComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1277652_1
updateIndependentTaskBusinessProcessingComReqDto.setTaskNumber(reqDto.getTaskNumber());//SimpleFieldAssign//sourceId:1277653_1
updateIndependentTaskBusinessProcessingComReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:1277654_1
updateIndependentTaskBusinessProcessingComReqDto.setTaskDesc(reqDto.getTaskDesc());//SimpleFieldAssign//sourceId:1277659_1
updateIndependentTaskBusinessProcessingComReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:1996885_1
updateIndependentTaskBusinessProcessingComReqDto.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1996886_1
updateIndependentTaskBusinessProcessingComReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1996887_1
updateIndependentTaskBusinessProcessingComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1996888_1
updateIndependentTaskBusinessProcessingComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1996186_1
updateIndependentTaskBusinessProcessingComReqDto.setReceiveSubjectId(reqDto.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1277655_1
updateIndependentTaskBusinessProcessingComReqDto.setOfficialDocumentId(reqDto.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1346343_1
updateIndependentTaskBusinessProcessingComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1277657_1
updateIndependentTaskBusinessProcessingComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1277656_1
updateIndependentTaskBusinessProcessingComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1277658_1
updateIndependentTaskBusinessProcessingComReqDto.setMessageImportantLevel(reqDto.getMessageImportantLevel());//SimpleFieldAssign//sourceId:1357017_1
updateIndependentTaskBusinessProcessingComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1366248_1
updateIndependentTaskBusinessProcessingComReqDto.setBusinessOperationTypeCode(reqDto.getBusinessOperationTypeCode());//SimpleFieldAssign//sourceId:1365439_1
updateIndependentTaskBusinessProcessingComReqDto.setDeptLeaderInductionRecordId(reqDto.getDeptLeaderInductionRecordId());//SimpleFieldAssign//sourceId:1366069_1
    }
  
    /*D3修改独立任务（或子任务）业务处理(公共)[7856]   */
    Assert.isNull(updateIndependentTaskBusinessProcessingComReqDto.getTaskId(),"B3修改独立任务或子任务-D3修改独立任务（或子任务）业务处理(公共)-任务ID不能为空",false);
      updateIndependentTaskBusinessProcessingComRespDto = fwAppWorkTasksClient.updateIndependentTaskBusinessProcessingCom(updateIndependentTaskBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffUpdateIndependentTaskRespDto retData = new BffUpdateIndependentTaskRespDto();
  
  

  
  
return retData;
  }
/**
   * B3查询独立任务详情[7794]
   * gen by moon at 8/31/2024, 1:11:42 PM
   */
    @Trace(operationName = "B3查询独立任务详情")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryIndependentTaskDetailRespDto queryIndependentTaskDetail(BffQueryIndependentTaskDetailReqDto reqDto){
      
       
       QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto_1 =null;
QueryWorkTaskSourceDetailComRespDto queryWorkTaskSourceDetailComRespDto_1 =null;
QueryMessageDetailComRespDto queryMessageDetailComRespDto_1 =null;
QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto_1 =null;
ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_1 =null;
QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto_1 =null;
QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailComRespDto_1 =null;
QueryOfficialDocumentDetailComRespDto queryOfficialDocumentDetailComRespDto_1 =null;
ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_3 =null;
ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_6 =null;
//virtualUsage D3查询独立任务详情(公共)  52409
     QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto = null;
    QueryIndependentTaskDetailComReqDto queryIndependentTaskDetailComReqDto=new QueryIndependentTaskDetailComReqDto();
  queryIndependentTaskDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1264168_1_52409
if(reqDto!=null){
      queryIndependentTaskDetailComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1258353_1_52409
    }
  
    /*D3查询独立任务详情(公共)[7793]   */
    Assert.isNull(queryIndependentTaskDetailComReqDto.getTaskId(),"B3查询独立任务详情-D3查询独立任务详情(公共)-任务ID不能为空",false);
    Assert.isNull(queryIndependentTaskDetailComReqDto.getSpaceId(),"B3查询独立任务详情-D3查询独立任务详情(公共)-创建于空间ID不能为空",false);
      queryIndependentTaskDetailComRespDto = fwAppWorkTasksClient.queryIndependentTaskDetailCom(queryIndependentTaskDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryIndependentTaskDetailComRespDto_1 = queryIndependentTaskDetailComRespDto;
//virtualUsage D1查询工作任务来源详情(公共)  68283
      QueryWorkTaskSourceDetailComRespDto queryWorkTaskSourceDetailComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          QueryWorkTaskSourceDetailComReqDto queryWorkTaskSourceDetailComReqDto=new QueryWorkTaskSourceDetailComReqDto();
if(queryIndependentTaskDetailComRespDto!=null){
      queryWorkTaskSourceDetailComReqDto.setTypeDictionaryCode(queryIndependentTaskDetailComRespDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1792165_1_68283
    }

    /*D1查询工作任务来源详情(公共)[9114]   */
    Assert.isNull(queryWorkTaskSourceDetailComReqDto.getTypeDictionaryCode(),"B3查询独立任务详情-D1查询工作任务来源详情(公共)-类型字典编码不能为空",false);
      queryWorkTaskSourceDetailComRespDto = fwBaseOrgDictionaryClient.queryWorkTaskSourceDetailCom(queryWorkTaskSourceDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryWorkTaskSourceDetailComRespDto_1 = queryWorkTaskSourceDetailComRespDto;
           }
//virtualUsage D2查任务签收状态  54465
      QueryMessageDetailComRespDto queryMessageDetailComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          QueryMessageDetailComReqDto queryMessageDetailComReqDto=new QueryMessageDetailComReqDto();
  queryMessageDetailComReqDto.setBehaviorTypeCode("GENERATE_TO_BE_SIGNED_WORK_TASK_MSG_TEMP");//CUSTOM_CONVENTION//sourceId:1346513_1_54465
queryMessageDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1346514_1_54465
if(queryIndependentTaskDetailComRespDto!=null){
      queryMessageDetailComReqDto.setEntityId(queryIndependentTaskDetailComRespDto.getTaskId());//SimpleFieldAssign//sourceId:1346512_1_54465
    }

    /*D2查任务签收状态[7526]   */
    Assert.isNull(queryMessageDetailComReqDto.getEntityId(),"B3查询独立任务详情-D2查任务签收状态-归属内容ID不能为空",false);
Assert.isNull(queryMessageDetailComReqDto.getBehaviorTypeCode(),"B3查询独立任务详情-D2查任务签收状态-行为类型编码不能为空",false);
Assert.isNull(queryMessageDetailComReqDto.getSpaceId(),"B3查询独立任务详情-D2查任务签收状态-创建于空间ID不能为空",false);
      queryMessageDetailComRespDto = fwCompMessageClient.queryMessageDetailCom(queryMessageDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryMessageDetailComRespDto_1 = queryMessageDetailComRespDto;
           }
//virtualUsage D1查任务操作人就职记录  52413
     QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto=new QueryInductionRecordInfoDetailComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      queryInductionRecordInfoDetailComReqDto.setInductionRecordId(queryIndependentTaskDetailComRespDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1263937_1_52413
    }
  
    /*D1查任务操作人就职记录[715]   */

      queryInductionRecordInfoDetailComRespDto = fwBaseInductionRecordClient.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryInductionRecordInfoDetailComRespDto_1 = queryInductionRecordInfoDetailComRespDto;
           }
//virtualUsage D3获取接收部门名称(公共)  52656
      ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto=new ObtainMainBodyObjectComReqDto();
  obtainMainBodyObjectComReqDto.setTableTypeCode("OMS_ORG_DEPT");//sourceId:1279867_1_52656
if(queryIndependentTaskDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto.setEntityId(queryIndependentTaskDetailComRespDto.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1279868_1_52656
    }

    /*D3获取接收部门名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto.getTableTypeCode(),"B3查询独立任务详情-D3获取接收部门名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto.getEntityId(),"B3查询独立任务详情-D3获取接收部门名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_1 = obtainMainBodyObjectComRespDto;
           }
//virtualUsage D3-3查询周期阶段资料详情(公共)  72092
      QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto=new QueryCycleStageDataDetailComReqDto();
  queryCycleStageDataDetailComReqDto.setIsInputData("TRUE");//sourceId:1966230_1_72092
queryCycleStageDataDetailComReqDto.setStageContentType("WORK_TASK_SUM_CON");//sourceId:1966232_1_72092
queryCycleStageDataDetailComReqDto.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1966254_1_72092
queryCycleStageDataDetailComReqDto.setSubjectLifeCycle("EDITING");//sourceId:1966239_1_72092
queryCycleStageDataDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1966240_1_72092
if(queryIndependentTaskDetailComRespDto!=null){
      queryCycleStageDataDetailComReqDto.setCycleDataObjId(queryIndependentTaskDetailComRespDto.getTaskId());//SimpleFieldAssign//sourceId:1966235_1_72092
queryCycleStageDataDetailComReqDto.setBelongToContentId(queryIndependentTaskDetailComRespDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1966236_1_72092
    }

    /*D3-3查询周期阶段资料详情(公共)[3962]   */
    Assert.isNull(queryCycleStageDataDetailComReqDto.getIsInputData(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-是否人工输入内容不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getStageContentType(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-内容性质类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleDataTypeCode(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-周期阶段资料类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleDataObjId(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getBelongToContentId(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-归属内容ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSubjectLifeCycle(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSpaceId(),"B3查询独立任务详情-D3-3查询周期阶段资料详情(公共)-创建于空间ID不能为空",false);
      queryCycleStageDataDetailComRespDto = fwAppCycleStageDataClient.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryCycleStageDataDetailComRespDto_1 = queryCycleStageDataDetailComRespDto;
           }
if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getParentTableTypeCode() !=null && queryIndependentTaskDetailComRespDto.getParentTableTypeCode().equals("OMS_TARGET_OBJECTIVE")&&queryIndependentTaskDetailComRespDto!= null&& queryIndependentTaskDetailComRespDto.getParentEntityId() != null &&queryIndependentTaskDetailComRespDto!= null&& queryIndependentTaskDetailComRespDto.getObjectiveId() != null)) {
        //if((D3查询独立任务详情(公共).父内容表类型编码 等于 指标表 and D3查询独立任务详情(公共).父内容表主键ID 值不等于空 ))  56616

QueryTargetObjectiveDetailComRespDto queryTargetObjectiveDetailComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          QueryTargetObjectiveDetailComReqDto queryTargetObjectiveDetailComReqDto=new QueryTargetObjectiveDetailComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      queryTargetObjectiveDetailComReqDto.setObjectiveId(queryIndependentTaskDetailComRespDto.getObjectiveId());//SimpleFieldAssign//sourceId:1992448_1_72760
    }

    /*D3查询指标详情(公共)[9412]   */
    Assert.isNull(queryTargetObjectiveDetailComReqDto.getObjectiveId(),"B3查询独立任务详情-D3查询指标详情(公共)-指标ID不能为空",false);
      queryTargetObjectiveDetailComRespDto = fwAppTargetContComClient.queryTargetObjectiveDetailCom(queryTargetObjectiveDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryTargetObjectiveDetailComRespDto_1 = queryTargetObjectiveDetailComRespDto;
           }
      }
if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getSourceTypeCode() !=null && queryIndependentTaskDetailComRespDto.getSourceTypeCode().equals("DOCUMENT_TASKS"))) {
        //if(D3查询独立任务详情(公共).来源类型编码 等于 公文任务)  54425

QueryOfficialDocumentDetailComRespDto queryOfficialDocumentDetailComRespDto = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          QueryOfficialDocumentDetailComReqDto queryOfficialDocumentDetailComReqDto=new QueryOfficialDocumentDetailComReqDto();
  queryOfficialDocumentDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1345959_1_54426
if(queryIndependentTaskDetailComRespDto!=null){
      queryOfficialDocumentDetailComReqDto.setArrangeWorkTaskId(queryIndependentTaskDetailComRespDto.getTaskId());//SimpleFieldAssign//sourceId:1345988_1_54426
    }

    /*D3-9查关联的公文信息(公共)[7930]   */
    Assert.isNull(queryOfficialDocumentDetailComReqDto.getArrangeWorkTaskId(),"B3查询独立任务详情-D3-9查关联的公文信息(公共)-安排的工作任务ID不能为空",false);
Assert.isNull(queryOfficialDocumentDetailComReqDto.getSpaceId(),"B3查询独立任务详情-D3-9查关联的公文信息(公共)-创建于空间ID不能为空",false);
      queryOfficialDocumentDetailComRespDto = fwAppOfficialDocumentClient.queryOfficialDocumentDetailCom(queryOfficialDocumentDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryOfficialDocumentDetailComRespDto_1 = queryOfficialDocumentDetailComRespDto;
           }
      }
if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getArrangeSubjectTypeCode() !=null && queryIndependentTaskDetailComRespDto.getArrangeSubjectTypeCode().equals("OMS_ORG_ORGANIZATION"))) {
        //if(D3查询独立任务详情(公共).安排主体类型编码 等于 组织表)  52414

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_2 = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_1=new ObtainMainBodyObjectComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_1.setTableTypeCode(queryIndependentTaskDetailComRespDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1279871_1_52657
obtainMainBodyObjectComReqDto_1.setEntityId(queryIndependentTaskDetailComRespDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1279872_1_52657
    }

    /*D3获取安排主体名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_1.getTableTypeCode(),"B3查询独立任务详情-D3获取安排主体名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_1.getEntityId(),"B3查询独立任务详情-D3获取安排主体名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_2 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_3 = obtainMainBodyObjectComRespDto_2;
           }
      }
else if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getArrangeSubjectTypeCode() !=null && queryIndependentTaskDetailComRespDto.getArrangeSubjectTypeCode().equals("OMS_ORG_DEPT"))){
       //elseif(D3查询独立任务详情(公共).安排主体类型编码 等于 部门表)  52415

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_4 = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_2=new ObtainMainBodyObjectComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_2.setTableTypeCode(queryIndependentTaskDetailComRespDto.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1279871_1_52658
obtainMainBodyObjectComReqDto_2.setEntityId(queryIndependentTaskDetailComRespDto.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1279872_1_52658
    }

    /*D3获取安排主体名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_2.getTableTypeCode(),"B3查询独立任务详情-D3获取安排主体名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_2.getEntityId(),"B3查询独立任务详情-D3获取安排主体名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_4 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_3 = obtainMainBodyObjectComRespDto_4;
           }
    }
else{
       //else  52416

//异常结束 52417
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode() !=null && queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode().equals("OMS_ORG_DEPT"))) {
        //if(D3查询独立任务详情(公共).归属对象类型编码 等于 部门表)  52419

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_5 = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_3=new ObtainMainBodyObjectComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_3.setTableTypeCode(queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1279875_1_52659
obtainMainBodyObjectComReqDto_3.setEntityId(queryIndependentTaskDetailComRespDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1279876_1_52659
    }

    /*D3获取归属主体名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_3.getTableTypeCode(),"B3查询独立任务详情-D3获取归属主体名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_3.getEntityId(),"B3查询独立任务详情-D3获取归属主体名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_5 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_6 = obtainMainBodyObjectComRespDto_5;
           }
      }
else if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode() !=null && queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode().equals("OMS_FRAMEWORK_SPACE"))){
       //elseif(D3查询独立任务详情(公共).归属对象类型编码 等于 空间表)  52421

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_7 = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_4=new ObtainMainBodyObjectComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_4.setTableTypeCode(queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1279875_1_52660
obtainMainBodyObjectComReqDto_4.setEntityId(queryIndependentTaskDetailComRespDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1279876_1_52660
    }

    /*D3获取归属主体名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_4.getTableTypeCode(),"B3查询独立任务详情-D3获取归属主体名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_4.getEntityId(),"B3查询独立任务详情-D3获取归属主体名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_7 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_6 = obtainMainBodyObjectComRespDto_7;
           }
    }
else if((queryIndependentTaskDetailComRespDto!= null&&  queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode() !=null && queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode().equals("OMS_TASK"))){
       //elseif(D3查询独立任务详情(公共).归属对象类型编码 等于 任务表)  52422

ObtainMainBodyObjectComRespDto obtainMainBodyObjectComRespDto_8 = null;
    if(queryIndependentTaskDetailComRespDto !=null){
          ObtainMainBodyObjectComReqDto obtainMainBodyObjectComReqDto_5=new ObtainMainBodyObjectComReqDto();
  if(queryIndependentTaskDetailComRespDto!=null){
      obtainMainBodyObjectComReqDto_5.setTableTypeCode(queryIndependentTaskDetailComRespDto.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1279875_1_52661
obtainMainBodyObjectComReqDto_5.setEntityId(queryIndependentTaskDetailComRespDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1279876_1_52661
    }

    /*D3获取归属主体名称(公共)[7859]   */
    Assert.isNull(obtainMainBodyObjectComReqDto_5.getTableTypeCode(),"B3查询独立任务详情-D3获取归属主体名称(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainMainBodyObjectComReqDto_5.getEntityId(),"B3查询独立任务详情-D3获取归属主体名称(公共)-内容表主键ID不能为空",false);
      obtainMainBodyObjectComRespDto_8 = fwAppWorkTasksClient.obtainMainBodyObjectCom(obtainMainBodyObjectComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainMainBodyObjectComRespDto_6 = obtainMainBodyObjectComRespDto_8;
           }
    }
else{
       //else  52423

//异常结束 52424
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
BffQueryIndependentTaskDetailRespDto retData = new BffQueryIndependentTaskDetailRespDto();
  if(queryIndependentTaskDetailComRespDto_1!=null){
      retData.setTaskId(queryIndependentTaskDetailComRespDto_1.getTaskId());//SimpleFieldAssign//sourceId:1264138_1
retData.setTaskNumber(queryIndependentTaskDetailComRespDto_1.getTaskNumber());//SimpleFieldAssign//sourceId:1264140_1
retData.setTaskName(queryIndependentTaskDetailComRespDto_1.getTaskName());//SimpleFieldAssign//sourceId:1264141_1
retData.setTaskDesc(queryIndependentTaskDetailComRespDto_1.getTaskDesc());//SimpleFieldAssign//sourceId:1264142_1
retData.setTaskType(queryIndependentTaskDetailComRespDto_1.getTaskType());//SimpleFieldAssign//sourceId:1264139_1
retData.setWorkTaskType(queryIndependentTaskDetailComRespDto_1.getWorkTaskType());//SimpleFieldAssign//sourceId:1400541_1
retData.setSourceTypeCode(queryIndependentTaskDetailComRespDto_1.getSourceTypeCode());//SimpleFieldAssign//sourceId:1264143_1
retData.setArrangeSubjectId(queryIndependentTaskDetailComRespDto_1.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1264144_1
retData.setReceiveSubjectId(queryIndependentTaskDetailComRespDto_1.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1264145_1
retData.setCoordObjectTypeCode(queryIndependentTaskDetailComRespDto_1.getCoordObjectTypeCode());//SimpleFieldAssign//sourceId:1400623_1
retData.setCoordObjectId(queryIndependentTaskDetailComRespDto_1.getCoordObjectId());//SimpleFieldAssign//sourceId:1264146_1
retData.setPlanStartTime(queryIndependentTaskDetailComRespDto_1.getPlanStartTime());//SimpleFieldAssign//sourceId:1264147_1
retData.setPlanEndTime(queryIndependentTaskDetailComRespDto_1.getPlanEndTime());//SimpleFieldAssign//sourceId:1264148_1
retData.setOriPlanStartTime(queryIndependentTaskDetailComRespDto_1.getOriPlanStartTime());//SimpleFieldAssign//sourceId:1474847_1
retData.setOriPlanEndTime(queryIndependentTaskDetailComRespDto_1.getOriPlanEndTime());//SimpleFieldAssign//sourceId:1474848_1
retData.setActualStartTime(queryIndependentTaskDetailComRespDto_1.getActualStartTime());//SimpleFieldAssign//sourceId:1264149_1
retData.setActualEndTime(queryIndependentTaskDetailComRespDto_1.getActualEndTime());//SimpleFieldAssign//sourceId:1264150_1
retData.setTotalLength(queryIndependentTaskDetailComRespDto_1.getTotalLength());//SimpleFieldAssign//sourceId:1264151_1
retData.setDeflectionStartDays(queryIndependentTaskDetailComRespDto_1.getDeflectionStartDays());//SimpleFieldAssign//sourceId:1264152_1
retData.setDeflectionEndDays(queryIndependentTaskDetailComRespDto_1.getDeflectionEndDays());//SimpleFieldAssign//sourceId:1264153_1
retData.setDeflectionTime(queryIndependentTaskDetailComRespDto_1.getDeflectionTime());//SimpleFieldAssign//sourceId:1264154_1
retData.setDeflectionInfo(queryIndependentTaskDetailComRespDto_1.getDeflectionInfo());//SimpleFieldAssign//sourceId:1264155_1
retData.setPercentageProgress(queryIndependentTaskDetailComRespDto_1.getPercentageProgress());//SimpleFieldAssign//sourceId:1264156_1
retData.setTaskStatus(queryIndependentTaskDetailComRespDto_1.getTaskStatus());//SimpleFieldAssign//sourceId:1346517_1
retData.setStateCode(queryIndependentTaskDetailComRespDto_1.getStateCode());//SimpleFieldAssign//sourceId:1475619_1
retData.setIsOverdue(queryIndependentTaskDetailComRespDto_1.getIsOverdue());//SimpleFieldAssign//sourceId:1424710_1
retData.setIsComplete(queryIndependentTaskDetailComRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:1471356_1
retData.setCompleteStatus(queryIndependentTaskDetailComRespDto_1.getCompleteStatus());//SimpleFieldAssign//sourceId:1469134_1
retData.setSubjectLifeCycle(queryIndependentTaskDetailComRespDto_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1264164_1
retData.setRelevantPeopleNum(queryIndependentTaskDetailComRespDto_1.getRelevantPeopleNum());//SimpleFieldAssign//sourceId:1264163_1
retData.setIsSystemTask(queryIndependentTaskDetailComRespDto_1.getIsSystemTask());//SimpleFieldAssign//sourceId:1354145_1
retData.setOperationInductionId(queryIndependentTaskDetailComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1264165_1
retData.setOperateTime(queryIndependentTaskDetailComRespDto_1.getOperateTime());//SimpleFieldAssign//sourceId:1264166_1
    }
if(queryWorkTaskSourceDetailComRespDto_1!=null){
      retData.setSourceName(queryWorkTaskSourceDetailComRespDto_1.getTypeDictionaryName());//SimpleFieldAssign//sourceId:1792169_1
    }
if(obtainMainBodyObjectComRespDto_3!=null){
      retData.setArrangeSubjectName(obtainMainBodyObjectComRespDto_3.getObjectName());//SimpleFieldAssign//sourceId:1279880_1
    }
if(obtainMainBodyObjectComRespDto_1!=null){
      retData.setReceiveSubjectName(obtainMainBodyObjectComRespDto_1.getObjectName());//SimpleFieldAssign//sourceId:1279879_1
    }
if(obtainMainBodyObjectComRespDto_6!=null){
      retData.setCoordObjectName(obtainMainBodyObjectComRespDto_6.getObjectName());//SimpleFieldAssign//sourceId:1279881_1
    }
if(queryCycleStageDataDetailComRespDto_1!=null){
      retData.setCycleStageDataId(queryCycleStageDataDetailComRespDto_1.getCycleStageDataId());//SimpleFieldAssign//sourceId:1966258_1
    }
if(queryTargetObjectiveDetailComRespDto_1!=null){
      retData.setObjectiveShortName(queryTargetObjectiveDetailComRespDto_1.getObjectiveShortName());//SimpleFieldAssign//sourceId:1992468_1
    }
if(queryOfficialDocumentDetailComRespDto_1!=null){
      retData.setOfficialDocumentId(queryOfficialDocumentDetailComRespDto_1.getOfficialDocumentId());//SimpleFieldAssign//sourceId:1345991_1
retData.setOfficialDocumentName(queryOfficialDocumentDetailComRespDto_1.getOfficialDocumentName());//SimpleFieldAssign//sourceId:1345992_1
    }
if(queryMessageDetailComRespDto_1!=null){
      retData.setIsHandle(queryMessageDetailComRespDto_1.getIsHandle());//SimpleFieldAssign//sourceId:1346516_1
    }
if(queryInductionRecordInfoDetailComRespDto_1!=null){
      retData.setUserId(queryInductionRecordInfoDetailComRespDto_1.getUserId());//SimpleFieldAssign//sourceId:1270019_1
retData.setUserFace(queryInductionRecordInfoDetailComRespDto_1.getUserFace());//SimpleFieldAssign//sourceId:1270022_1
retData.setIdCardName(queryInductionRecordInfoDetailComRespDto_1.getIdCardName());//SimpleFieldAssign//sourceId:1270020_1
retData.setNickName(queryInductionRecordInfoDetailComRespDto_1.getNickName());//SimpleFieldAssign//sourceId:1270021_1
    }


  
  
return retData;
  }
/**
   * B3删除独立任务[7797]
   * gen by moon at 11/10/2023, 3:57:57 PM
   */
    @Trace(operationName = "B3删除独立任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffDeleteIndependentTaskRespDto deleteIndependentTask(BffDeleteIndependentTaskReqDto reqDto){
      
       
       //步骤0: D3删除独立任务业务处理(公共) - deleteIndependentTaskBusinessProcessingCom
     DeleteIndependentTaskBusinessProcessingComRespDto deleteIndependentTaskBusinessProcessingComRespDto = null;
    DeleteIndependentTaskBusinessProcessingComReqDto deleteIndependentTaskBusinessProcessingComReqDto=new DeleteIndependentTaskBusinessProcessingComReqDto();
  if(reqDto!=null){
      deleteIndependentTaskBusinessProcessingComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1280256_1
    }
  
    /*D3删除独立任务业务处理(公共)[7863]   */
    Assert.isNull(deleteIndependentTaskBusinessProcessingComReqDto.getTaskId(),"B3删除独立任务-D3删除独立任务业务处理(公共)-任务ID不能为空",false);
      deleteIndependentTaskBusinessProcessingComRespDto = fwAppWorkTasksClient.deleteIndependentTaskBusinessProcessingCom(deleteIndependentTaskBusinessProcessingComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffDeleteIndependentTaskRespDto retData = new BffDeleteIndependentTaskRespDto();
  
  

  
  
return retData;
  }
/**
   * B3存档独立任务[7801]
   * gen by moon at 11/8/2023, 4:24:32 PM
   */
    @Trace(operationName = "B3存档独立任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffArchiveIndependentTaskRespDto archiveIndependentTask(BffArchiveIndependentTaskReqDto reqDto){
      
       
       //步骤0: D3存档独立任务 - archiveIndependentTask
     ArchiveIndependentTaskRespDto archiveIndependentTaskRespDto = null;
    ArchiveIndependentTaskReqDto archiveIndependentTaskReqDto=new ArchiveIndependentTaskReqDto();
  if(reqDto!=null){
      archiveIndependentTaskReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1264672_1
archiveIndependentTaskReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1264673_1
archiveIndependentTaskReqDto.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1264674_1
    }
  
    /*D3存档独立任务[7800]   */
    Assert.isNull(archiveIndependentTaskReqDto.getTaskId(),"B3存档独立任务-D3存档独立任务-任务ID不能为空",false);
Assert.isNull(archiveIndependentTaskReqDto.getSubjectLifeCycle(),"B3存档独立任务-D3存档独立任务-主体生命周期不能为空",false);
Assert.isNull(archiveIndependentTaskReqDto.getIsArchive(),"B3存档独立任务-D3存档独立任务-是否存档不能为空",false);
      archiveIndependentTaskRespDto = fwAppWorkTasksClient.archiveIndependentTask(archiveIndependentTaskReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
BffArchiveIndependentTaskRespDto retData = new BffArchiveIndependentTaskRespDto();
  
  

  
  
return retData;
  }

  public String getReviewResult(String fileUrl){
      String apiUrl = "http://192.168.31.210/v1/workflows/run";
      String imageUrl = fileUrl;
      String bearerToken = "app-Q1ZDOOlbIR6EyE0tx9H5qUKc";
      String user = "abc-123";
      JSONObject reviewData = new JSONObject();

      try {
          URL url = new URL(apiUrl);
          HttpURLConnection connection = (HttpURLConnection) url.openConnection();
          connection.setRequestMethod("POST");
          connection.setRequestProperty("Authorization", "Bearer " + bearerToken);
          connection.setRequestProperty("Content-Type", "application/json");
          connection.setDoOutput(true);

          // 构造请求体
          String jsonInput = String.format(
                  "{"
                          + "\"inputs\": {"
                          + "  \"localImagefile\": ["
                          + "    {"
                          + "      \"transfer_method\": \"remote_url\","
                          + "      \"url\": \"%s\","
                          + "      \"type\": \"image\""
                          + "    }"
                          + "  ]"
                          + "},"
                          + "\"response_mode\": \"blocking\","
                          + "\"user\": \"%s\""
                          + "}",
                  imageUrl, user);

          // 发送请求体
          try (OutputStream os = connection.getOutputStream()) {
              byte[] input = jsonInput.getBytes("utf-8");
              os.write(input, 0, input.length);
          }

          // 获取响应码
          int responseCode = connection.getResponseCode();
          if (responseCode == HttpURLConnection.HTTP_OK) {
              // 读取响应内容
              StringBuilder response = new StringBuilder();
              try (BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                  String inputLine;
                  while ((inputLine = in.readLine()) != null) {
                      response.append(inputLine);
                  }
              }

              // 解析JSON响应
              JSONObject jsonResponse = JSONObject.parseObject(response.toString());
              System.out.println("Response JSON: " + jsonResponse.toJSONString()); // 格式化输出

              // 提取关键字段
              String workflowRunId = jsonResponse.getString("workflow_run_id");
              String taskId = jsonResponse.getString("task_id");
              String status = jsonResponse.getString("status");
              JSONObject data = jsonResponse.getJSONObject("data");
              JSONObject outputs = data.getJSONObject("outputs");
              String textData = outputs.getString("text2");
              reviewData = JSONObject.parseObject(textData);
          } else {
              System.out.println("Error: " + responseCode);
          }
      } catch (Exception e) {
          e.printStackTrace();
      }
      return reviewData.toJSONString();
  }


/**
   * B3-提交工作任务汇报[7869]
   * gen by moon at 8/10/2024, 1:27:33 PM
   */
    @Trace(operationName = "B3-提交工作任务汇报")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffCommitReportWorkTaskProgressRespDto commitReportWorkTaskProgress(BffCommitReportWorkTaskProgressReqDto reqDto){


       //步骤0: D3执行工作任务汇报业务处理 - implementWrokTaskReportBusinessProcess
     ImplementWrokTaskReportBusinessProcessRespDto implementWrokTaskReportBusinessProcessRespDto = null;
    ImplementWrokTaskReportBusinessProcessReqDto implementWrokTaskReportBusinessProcessReqDto=new ImplementWrokTaskReportBusinessProcessReqDto();
  implementWrokTaskReportBusinessProcessReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1966850_1
if(reqDto!=null){
      implementWrokTaskReportBusinessProcessReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1966856_1
implementWrokTaskReportBusinessProcessReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1966848_1
implementWrokTaskReportBusinessProcessReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1966851_1
implementWrokTaskReportBusinessProcessReqDto.setWorkTaskSumCon(reqDto.getWorkTaskSumCon());//SimpleFieldAssign//sourceId:1966852_1
implementWrokTaskReportBusinessProcessReqDto.setTextSummaryData(reqDto.getTextSummaryData());//SimpleFieldAssign//sourceId:1966853_1
implementWrokTaskReportBusinessProcessReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1966849_1
    }
if(reqDto!= null&&  reqDto.getCycleStageAttaPicList() !=null&& !CollectionUtil.isEmpty(reqDto.getCycleStageAttaPicList())){
      implementWrokTaskReportBusinessProcessReqDto.setCycleStageAttaPicList(reqDto.getCycleStageAttaPicList().stream().map(item -> BeanUtil.toBean(item, CycleStageAttaPicDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1966855_1
    }
if(reqDto!= null&&  reqDto.getCycleStageDataAttDocList() !=null&& !CollectionUtil.isEmpty(reqDto.getCycleStageDataAttDocList())){
      implementWrokTaskReportBusinessProcessReqDto.setCycleStageDataAttDocList(reqDto.getCycleStageDataAttDocList().stream().map(item -> BeanUtil.toBean(item, CycleStageDataAttDocDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1966854_1
    }

    /*D3执行工作任务汇报业务处理[10069]   */
    Assert.isNull(implementWrokTaskReportBusinessProcessReqDto.getTaskId(),"B3-提交工作任务汇报-D3执行工作任务汇报业务处理-任务ID不能为空",false);
Assert.isNull(implementWrokTaskReportBusinessProcessReqDto.getProgressValue(),"B3-提交工作任务汇报-D3执行工作任务汇报业务处理-进度值（数值）不能为空",false);
Assert.isNull(implementWrokTaskReportBusinessProcessReqDto.getWorkTaskSumCon(),"B3-提交工作任务汇报-D3执行工作任务汇报业务处理-工作任务总结内容不能为空",false);
Assert.isNull(implementWrokTaskReportBusinessProcessReqDto.getTextSummaryData(),"B3-提交工作任务汇报-D3执行工作任务汇报业务处理-资料文字概要不能为空",false);
Assert.isNull(implementWrokTaskReportBusinessProcessReqDto.getSubjectLifeCycle(),"B3-提交工作任务汇报-D3执行工作任务汇报业务处理-主体生命周期不能为空",false);
Assert.isNull(implementWrokTaskReportBusinessProcessReqDto.getSpaceId(),"B3-提交工作任务汇报-D3执行工作任务汇报业务处理-创建于空间ID不能为空",false);
      implementWrokTaskReportBusinessProcessRespDto = fwAppWorkTasksClient.implementWrokTaskReportBusinessProcess(implementWrokTaskReportBusinessProcessReqDto).getData()/*vcase invoke 跨dubbo调用;*/;

//        // TODO: 2025/4/28
//        if(reqDto.getCycleStageDataAttDocList()!=null){
//            for(BffCycleStageDataAttDocDto one : reqDto.getCycleStageDataAttDocList()){
//                if(one.getFileRelativePathAccess()!=null){
//                    String fullFile = CommonFunctionHelper.getFilePath(one.getFileRelativePathAccess());
//                    String result = getReviewResult(fullFile);
//                    JSONObject reviewResult = JSONObject.parseObject(result);
//                    JSONArray questions = reviewResult.getJSONArray("questions");
//                    Integer scrore = reviewResult.getInteger("testScore");
//                    if(questions!=null && questions.size()>0){
//                        for (int i = 0; i < questions.size(); i++) {
//                            JSONObject question = questions.getJSONObject(i);
//                            String title = question.getString("title");
//                            JSONObject description = question.getJSONObject("description");
//                            String standardAnswer = description.getString("standardAnswer");
//                            String expertAdvice = description.getString("expertAdvice");
//                            AddQuestionBusinessProcessingComReqDto messageReq = new AddQuestionBusinessProcessingComReqDto();
//                            messageReq.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());
//                            messageReq.setQuestionIntroduce(title);
//                            messageReq.setQuestionDesc("参考答案：【" + standardAnswer + "】，" + "解读：【" + expertAdvice + "】");
//                            messageReq.setArrangeSubjectId("128600919301693440");
//                            messageReq.setArrangeSubjectTypeCode("OMS_ORG_DEPT");
//                            messageReq.setCoordObjectId(reqDto.getTaskId());
//                            messageReq.setCoordObjectTypeCode("OMS_TASK");
//                            messageReq.setPrincipalInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());
//                            messageReq.setQuestionLevel("TINY");
//                            messageReq.setSourceTypeCode("TEMPORARY_TASK");
//                            messageReq.setSubjectLifeCycle("CURRENTLY_VALID");
//                            AddQuestionBusinessProcessingComRespDto addQuestionBusinessProcessingComRespDto = fwAppQuestionClient.addQuestionBusinessProcessingCom(messageReq).getData()/*vcase invoke 跨dubbo调用;*/;
//                        }
//                    }
//
//                }
//            }
//        }


BffCommitReportWorkTaskProgressRespDto retData = new BffCommitReportWorkTaskProgressRespDto();





return retData;
  }
/**
   * B3获取高中基层工作任务场景权限[7909]
   * gen by moon at 9/7/2024, 1:38:08 PM
   */
    @Trace(operationName = "B3获取高中基层工作任务场景权限")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffObtainTopMidBasicScenePowerRespDto obtainTopMidBasicScenePower(BffObtainTopMidBasicScenePowerReqDto reqDto){


       ObtainReceiveFieldComRespDto obtainReceiveFieldComRespDto_3 =null;
//virtualUsage D3约定：当前身份人员及当前就职记录  59923
      ObtainReceiveFieldComRespDto obtainReceiveFieldComRespDto = null;
    ObtainReceiveFieldComReqDto obtainReceiveFieldComReqDto=new ObtainReceiveFieldComReqDto();
  obtainReceiveFieldComReqDto.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1493905_1_59923
obtainReceiveFieldComReqDto.setInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1493907_1_59923
obtainReceiveFieldComReqDto.setCustomField("1");//CUSTOM_CONVENTION//sourceId:1998255_1_59923

    /*D3约定：当前身份人员及当前就职记录[3774]   */
    Assert.isNull(obtainReceiveFieldComReqDto.getOriginalRoleMemberId(),"B3获取高中基层工作任务场景权限-D3约定：当前身份人员及当前就职记录-身份人员ID不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto.getInductionRecordId(),"B3获取高中基层工作任务场景权限-D3约定：当前身份人员及当前就职记录-就职记录ID不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto.getCustomField(),"B3获取高中基层工作任务场景权限-D3约定：当前身份人员及当前就职记录-自定义字段不能为空",false);
      obtainReceiveFieldComRespDto = fwAppDivineDataClient.obtainReceiveFieldCom(obtainReceiveFieldComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3获取高中基层工作任务场景权限  53571
      ObtainTopMidBasicScenePowerRespDto obtainTopMidBasicScenePowerRespDto = null;
    ObtainTopMidBasicScenePowerReqDto obtainTopMidBasicScenePowerReqDto=new ObtainTopMidBasicScenePowerReqDto();
  if(reqDto!=null){
      obtainTopMidBasicScenePowerReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1305892_1_53571
obtainTopMidBasicScenePowerReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1305891_1_53571
    }

    /*D3获取高中基层工作任务场景权限[7911]   */
    Assert.isNull(obtainTopMidBasicScenePowerReqDto.getBatchOperateScene(),"B3获取高中基层工作任务场景权限-D3获取高中基层工作任务场景权限-高/中/基层操作场景不能为空",false);
      obtainTopMidBasicScenePowerRespDto = fwAppWorkTasksClient.obtainTopMidBasicScenePower(obtainTopMidBasicScenePowerReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D1-3-13查询单条就职记录详情(公共)  56655
      QuerySingleInductionRecordIdDetailComRespDto querySingleInductionRecordIdDetailComRespDto = null;
        QuerySingleInductionRecordIdDetailComReqDto querySingleInductionRecordIdDetailComReqDto=new QuerySingleInductionRecordIdDetailComReqDto();
  querySingleInductionRecordIdDetailComReqDto.setInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1414852_1_56655
if(reqDto!=null){
      querySingleInductionRecordIdDetailComReqDto.setEntityId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1414859_1_56655
    }

    /*D1-3-13查询单条就职记录详情(公共)[4306]   */
    Assert.isNull(querySingleInductionRecordIdDetailComReqDto.getInductionRecordId(),"B3获取高中基层工作任务场景权限-D1-3-13查询单条就职记录详情(公共)-就职记录ID不能为空",false);
Assert.isNull(querySingleInductionRecordIdDetailComReqDto.getEntityId(),"B3获取高中基层工作任务场景权限-D1-3-13查询单条就职记录详情(公共)-就职单位对象实例ID不能为空",false);
      querySingleInductionRecordIdDetailComRespDto = fwBaseSystemTestDomainClient.querySingleInductionRecordIdDetailCom(querySingleInductionRecordIdDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("MID")||reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("BASIC"))&&(querySingleInductionRecordIdDetailComRespDto!= null&& querySingleInductionRecordIdDetailComRespDto.getInductionRecordId() != null )) {
        //if((B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 中层 or B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 基层) and D1-3-13查当前就职记录是否入参部门直属成员.就职记录ID 值不等于空 )  72808

ObtainReceiveFieldComRespDto obtainReceiveFieldComRespDto_2 = null;
    if(obtainTopMidBasicScenePowerRespDto !=null&&obtainReceiveFieldComRespDto !=null){
    ObtainReceiveFieldComReqDto obtainReceiveFieldComReqDto_1=new ObtainReceiveFieldComReqDto();
  if(obtainTopMidBasicScenePowerRespDto!=null){
      obtainReceiveFieldComReqDto_1.setCustomField(obtainTopMidBasicScenePowerRespDto.getMyArrangeWrokTaskPower());//SimpleFieldAssign//sourceId:1998492_1_72810
obtainReceiveFieldComReqDto_1.setCustomField2(obtainTopMidBasicScenePowerRespDto.getMyQuestionPower());//SimpleFieldAssign//sourceId:1998494_1_72810
    }
if(obtainReceiveFieldComRespDto!=null){
      obtainReceiveFieldComReqDto_1.setCustomField1(obtainReceiveFieldComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1998493_1_72810
obtainReceiveFieldComReqDto_1.setCustomField3(obtainReceiveFieldComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1998495_1_72810
    }

    /*D3获取接收字段服务(公共)[3774]   */
    Assert.isNull(obtainReceiveFieldComReqDto_1.getCustomField(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto_1.getCustomField1(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段1不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto_1.getCustomField2(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段2不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto_1.getCustomField3(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段3不能为空",false);
      obtainReceiveFieldComRespDto_2 = fwAppDivineDataClient.obtainReceiveFieldCom(obtainReceiveFieldComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainReceiveFieldComRespDto_3 = obtainReceiveFieldComRespDto_2;
           }
      }
else if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("MID")&&querySingleInductionRecordIdDetailComRespDto!= null&& querySingleInductionRecordIdDetailComRespDto.getInductionRecordId() == null )||(reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("BASIC")&&querySingleInductionRecordIdDetailComRespDto!= null&& querySingleInductionRecordIdDetailComRespDto.getInductionRecordId() == null )||(reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("TOP"))){
       //elseif((B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 中层 and D1-3-13查当前就职记录是否入参部门直属成员.就职记录ID 值等于空 ) or (B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 基层 and D1-3-13查当前就职记录是否入参部门直属成员.就职记录ID 值等于空 ) or B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 高层)  72809

ObtainReceiveFieldComRespDto obtainReceiveFieldComRespDto_4 = null;
    if(obtainTopMidBasicScenePowerRespDto !=null){
          ObtainReceiveFieldComReqDto obtainReceiveFieldComReqDto_2=new ObtainReceiveFieldComReqDto();
  if(obtainTopMidBasicScenePowerRespDto!=null){
      obtainReceiveFieldComReqDto_2.setCustomField(obtainTopMidBasicScenePowerRespDto.getMyArrangeWrokTaskPower());//SimpleFieldAssign//sourceId:1998492_1_72811
obtainReceiveFieldComReqDto_2.setCustomField1(obtainTopMidBasicScenePowerRespDto.getAllWorkTaskPower());//SimpleFieldAssign//sourceId:1998493_1_72811
obtainReceiveFieldComReqDto_2.setCustomField2(obtainTopMidBasicScenePowerRespDto.getMyQuestionPower());//SimpleFieldAssign//sourceId:1998494_1_72811
obtainReceiveFieldComReqDto_2.setCustomField3(obtainTopMidBasicScenePowerRespDto.getAllQuestionPower());//SimpleFieldAssign//sourceId:1998495_1_72811
    }

    /*D3获取接收字段服务(公共)[3774]   */
    Assert.isNull(obtainReceiveFieldComReqDto_2.getCustomField(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto_2.getCustomField1(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段1不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto_2.getCustomField2(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段2不能为空",false);
Assert.isNull(obtainReceiveFieldComReqDto_2.getCustomField3(),"B3获取高中基层工作任务场景权限-D3获取接收字段服务(公共)-自定义字段3不能为空",false);
      obtainReceiveFieldComRespDto_4 = fwAppDivineDataClient.obtainReceiveFieldCom(obtainReceiveFieldComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainReceiveFieldComRespDto_3 = obtainReceiveFieldComRespDto_4;
           }
    }
if((obtainTopMidBasicScenePowerRespDto!= null&& obtainTopMidBasicScenePowerRespDto.getMyArrangeWrokTaskPower() != null &&obtainTopMidBasicScenePowerRespDto!= null&&  obtainTopMidBasicScenePowerRespDto.getMyArrangeWrokTaskPower() !=null && obtainTopMidBasicScenePowerRespDto.getMyArrangeWrokTaskPower().equals("1"))) {
        //if((D3获取高中基层工作任务场景权限.我安排的工作任务权限 值不等于空  and D3获取高中基层工作任务场景权限.我安排的工作任务权限 等于 1))  53572

ObtainReceiveFieldComRespDto obtainReceiveFieldComRespDto_5 = null;
    ObtainReceiveFieldComReqDto obtainReceiveFieldComReqDto_3=new ObtainReceiveFieldComReqDto();
  obtainReceiveFieldComReqDto_3.setWorkTaskObjectType("TASK");//sourceId:1493444_1_59924

    /*D3约定：工作任务[3774]   */
    Assert.isNull(obtainReceiveFieldComReqDto_3.getWorkTaskObjectType(),"B3获取高中基层工作任务场景权限-D3约定：工作任务-工作任务对象类型不能为空",false);
      obtainReceiveFieldComRespDto_5 = fwAppDivineDataClient.obtainReceiveFieldCom(obtainReceiveFieldComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("TOP"))) {
        //if(B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 高层)  53585

ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_5 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493159_1_59916
implementConcurrentBehaviorThemeLockComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1493164_1_59916
implementConcurrentBehaviorThemeLockComReqDto.setTimeUnitType("MINUTES");//sourceId:1493165_1_59916
implementConcurrentBehaviorThemeLockComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1493167_1_59916
implementConcurrentBehaviorThemeLockComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1493166_1_59916
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto.setCommPrimaryKey(obtainReceiveFieldComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1493160_1_59916
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493161_1_59916
    }
if(obtainReceiveFieldComRespDto_5!=null){
      implementConcurrentBehaviorThemeLockComReqDto.setCustomField2(obtainReceiveFieldComRespDto_5.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493162_1_59916
    }

    /*D3执行并发行为主题加锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getDuration(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-锁定时长不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getTimeUnitType(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-时间单位类型不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getHandlingMethodConcurrentLockFailure(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementConcurrentBehaviorThemeLockComRespDto!= null&&  implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D3执行并发行为主题加锁（工作任务）.防并发上锁情况 等于 空上锁成功)  59919

ImplementIniWorkTaskMsgLocationByLoginComRespDto implementIniWorkTaskMsgLocationByLoginComRespDto = null;
    ImplementIniWorkTaskMsgLocationByLoginComReqDto implementIniWorkTaskMsgLocationByLoginComReqDto=new ImplementIniWorkTaskMsgLocationByLoginComReqDto();
  implementIniWorkTaskMsgLocationByLoginComReqDto.setSurfaceCode("ORIGINAL_ROLE_MEMBER");//sourceId:1481763_1_59920
implementIniWorkTaskMsgLocationByLoginComReqDto.setEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1481764_1_59920
implementIniWorkTaskMsgLocationByLoginComReqDto.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:1312740_1_59920
implementIniWorkTaskMsgLocationByLoginComReqDto.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1312741_1_59920
implementIniWorkTaskMsgLocationByLoginComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1312743_1_59920

    /*D2-执行初始化高层工作任务消息数量(公共)[7878]   */
    Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto.getSurfaceCode(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层工作任务消息数量(公共)-归属内容类型编码不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto.getEntityId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层工作任务消息数量(公共)-归属内容ID不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto.getUserId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层工作任务消息数量(公共)-账号不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto.getOriginalRoleMemberId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层工作任务消息数量(公共)-身份人员ID不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto.getSpaceId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层工作任务消息数量(公共)-创建于空间ID不能为空",false);
      implementIniWorkTaskMsgLocationByLoginComRespDto = fwCompMessageClient.implementIniWorkTaskMsgLocationByLoginCom(implementIniWorkTaskMsgLocationByLoginComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_2 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_5 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_1=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_1.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493170_1_59921
implementConcurrentBehaviorThemeLockComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1493177_1_59921
implementConcurrentBehaviorThemeLockComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1493180_1_59921
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_1.setCommPrimaryKey(obtainReceiveFieldComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1493171_1_59921
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_1.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493172_1_59921
    }
if(obtainReceiveFieldComRespDto_5!=null){
      implementConcurrentBehaviorThemeLockComReqDto_1.setCustomField2(obtainReceiveFieldComRespDto_5.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493173_1_59921
    }

    /*D3执行并发行为主题解锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getWhetherUnlockBulk(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-是否批量解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_2 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
      }
else if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("MID")||reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("BASIC"))&&(querySingleInductionRecordIdDetailComRespDto!= null&& querySingleInductionRecordIdDetailComRespDto.getInductionRecordId() != null )){
       //elseif((B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 中层 or B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 基层) and D1-3-13查当前就职记录是否入参部门直属成员.就职记录ID 值不等于空 )  53586

ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_4 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_5 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_2=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_2.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493159_1_59925
implementConcurrentBehaviorThemeLockComReqDto_2.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1493164_1_59925
implementConcurrentBehaviorThemeLockComReqDto_2.setTimeUnitType("MINUTES");//sourceId:1493165_1_59925
implementConcurrentBehaviorThemeLockComReqDto_2.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1493167_1_59925
implementConcurrentBehaviorThemeLockComReqDto_2.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1493166_1_59925
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_2.setCommPrimaryKey(obtainReceiveFieldComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1493160_1_59925
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_2.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493161_1_59925
    }
if(obtainReceiveFieldComRespDto_5!=null){
      implementConcurrentBehaviorThemeLockComReqDto_2.setCustomField2(obtainReceiveFieldComRespDto_5.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493162_1_59925
    }

    /*D3执行并发行为主题加锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getDuration(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-锁定时长不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getTimeUnitType(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-时间单位类型不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getHandlingMethodConcurrentLockFailure(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_2.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_4 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementConcurrentBehaviorThemeLockComRespDto_4!= null&&  implementConcurrentBehaviorThemeLockComRespDto_4.getPreventConcurrentLockingSituations() !=null && implementConcurrentBehaviorThemeLockComRespDto_4.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D3执行并发行为主题加锁（当前身份人员中基层工作任务）.防并发上锁情况 等于 空上锁成功)  59926

ImplementIniWorkTaskMsgLocationByLoginComRespDto implementIniWorkTaskMsgLocationByLoginComRespDto_1 = null;
    ImplementIniWorkTaskMsgLocationByLoginComReqDto implementIniWorkTaskMsgLocationByLoginComReqDto_1=new ImplementIniWorkTaskMsgLocationByLoginComReqDto();
  implementIniWorkTaskMsgLocationByLoginComReqDto_1.setSurfaceCode("INDUCTION_RECORD");//sourceId:1481767_1_59927
implementIniWorkTaskMsgLocationByLoginComReqDto_1.setEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1481768_1_59927
implementIniWorkTaskMsgLocationByLoginComReqDto_1.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:1312747_1_59927
implementIniWorkTaskMsgLocationByLoginComReqDto_1.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1312748_1_59927
implementIniWorkTaskMsgLocationByLoginComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1312750_1_59927

    /*D2-执行初始化中基层工作任务消息数量(公共)[7878]   */
    Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto_1.getSurfaceCode(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层工作任务消息数量(公共)-归属内容类型编码不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto_1.getEntityId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层工作任务消息数量(公共)-归属内容ID不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto_1.getUserId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层工作任务消息数量(公共)-账号不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto_1.getOriginalRoleMemberId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层工作任务消息数量(公共)-身份人员ID不能为空",false);
Assert.isNull(implementIniWorkTaskMsgLocationByLoginComReqDto_1.getSpaceId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层工作任务消息数量(公共)-创建于空间ID不能为空",false);
      implementIniWorkTaskMsgLocationByLoginComRespDto_1 = fwCompMessageClient.implementIniWorkTaskMsgLocationByLoginCom(implementIniWorkTaskMsgLocationByLoginComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_5 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_5 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_3=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_3.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493170_1_59928
implementConcurrentBehaviorThemeLockComReqDto_3.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1493177_1_59928
implementConcurrentBehaviorThemeLockComReqDto_3.setWhetherUnlockBulk("FALSE");//sourceId:1493180_1_59928
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_3.setCommPrimaryKey(obtainReceiveFieldComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1493171_1_59928
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_3.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493172_1_59928
    }
if(obtainReceiveFieldComRespDto_5!=null){
      implementConcurrentBehaviorThemeLockComReqDto_3.setCustomField2(obtainReceiveFieldComRespDto_5.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493173_1_59928
    }

    /*D3执行并发行为主题解锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_3.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_3.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_3.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_3.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_3.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_3.getWhetherUnlockBulk(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-是否批量解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_5 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
    }
      }
if((obtainTopMidBasicScenePowerRespDto!= null&& obtainTopMidBasicScenePowerRespDto.getMyQuestionPower() != null &&obtainTopMidBasicScenePowerRespDto!= null&&  obtainTopMidBasicScenePowerRespDto.getMyQuestionPower() !=null && obtainTopMidBasicScenePowerRespDto.getMyQuestionPower().equals("1"))) {
        //if((D3获取高中基层工作任务场景权限.我提出的问题权限 值不等于空  and D3获取高中基层工作任务场景权限.我提出的问题权限 等于 1))  53573

ObtainReceiveFieldComRespDto obtainReceiveFieldComRespDto_7 = null;
    ObtainReceiveFieldComReqDto obtainReceiveFieldComReqDto_4=new ObtainReceiveFieldComReqDto();
  obtainReceiveFieldComReqDto_4.setWorkTaskObjectType("PROBLEM");//sourceId:1493675_1_59929

    /*D3约定：问题[3774]   */
    Assert.isNull(obtainReceiveFieldComReqDto_4.getWorkTaskObjectType(),"B3获取高中基层工作任务场景权限-D3约定：问题-工作任务对象类型不能为空",false);
      obtainReceiveFieldComRespDto_7 = fwAppDivineDataClient.obtainReceiveFieldCom(obtainReceiveFieldComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;



if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("TOP"))) {
        //if(B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 高层)  53600

ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_6 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_7 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_4=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_4.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493159_1_59930
implementConcurrentBehaviorThemeLockComReqDto_4.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1493164_1_59930
implementConcurrentBehaviorThemeLockComReqDto_4.setTimeUnitType("MINUTES");//sourceId:1493165_1_59930
implementConcurrentBehaviorThemeLockComReqDto_4.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1493167_1_59930
implementConcurrentBehaviorThemeLockComReqDto_4.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1493166_1_59930
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_4.setCommPrimaryKey(obtainReceiveFieldComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1493160_1_59930
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_4.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493161_1_59930
    }
if(obtainReceiveFieldComRespDto_7!=null){
      implementConcurrentBehaviorThemeLockComReqDto_4.setCustomField2(obtainReceiveFieldComRespDto_7.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493162_1_59930
    }

    /*D3执行并发行为主题加锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getDuration(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-锁定时长不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getTimeUnitType(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-时间单位类型不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getHandlingMethodConcurrentLockFailure(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_4.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_6 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementConcurrentBehaviorThemeLockComRespDto_6!= null&&  implementConcurrentBehaviorThemeLockComRespDto_6.getPreventConcurrentLockingSituations() !=null && implementConcurrentBehaviorThemeLockComRespDto_6.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D3执行并发行为主题加锁（问题）.防并发上锁情况 等于 空上锁成功)  59931

ImplementIniProblemMsgLocationByLoginComRespDto implementIniProblemMsgLocationByLoginComRespDto = null;
    ImplementIniProblemMsgLocationByLoginComReqDto implementIniProblemMsgLocationByLoginComReqDto=new ImplementIniProblemMsgLocationByLoginComReqDto();
  implementIniProblemMsgLocationByLoginComReqDto.setSurfaceCode("ORIGINAL_ROLE_MEMBER");//sourceId:1481722_1_59932
implementIniProblemMsgLocationByLoginComReqDto.setEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1481723_1_59932
implementIniProblemMsgLocationByLoginComReqDto.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:1312793_1_59932
implementIniProblemMsgLocationByLoginComReqDto.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1312794_1_59932
implementIniProblemMsgLocationByLoginComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1312796_1_59932

    /*D2-执行初始化高层问题消息数量(公共)[7879]   */
    Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto.getSurfaceCode(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层问题消息数量(公共)-归属内容类型编码不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto.getEntityId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层问题消息数量(公共)-归属内容ID不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto.getUserId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层问题消息数量(公共)-账号不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto.getOriginalRoleMemberId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层问题消息数量(公共)-身份人员ID不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto.getSpaceId(),"B3获取高中基层工作任务场景权限-D2-执行初始化高层问题消息数量(公共)-创建于空间ID不能为空",false);
      implementIniProblemMsgLocationByLoginComRespDto = fwCompMessageClient.implementIniProblemMsgLocationByLoginCom(implementIniProblemMsgLocationByLoginComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_7 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_7 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_5=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_5.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493170_1_59933
implementConcurrentBehaviorThemeLockComReqDto_5.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1493177_1_59933
implementConcurrentBehaviorThemeLockComReqDto_5.setWhetherUnlockBulk("FALSE");//sourceId:1493180_1_59933
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_5.setCommPrimaryKey(obtainReceiveFieldComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1493171_1_59933
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_5.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493172_1_59933
    }
if(obtainReceiveFieldComRespDto_7!=null){
      implementConcurrentBehaviorThemeLockComReqDto_5.setCustomField2(obtainReceiveFieldComRespDto_7.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493173_1_59933
    }

    /*D3执行并发行为主题解锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_5.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_5.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_5.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_5.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_5.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_5.getWhetherUnlockBulk(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-是否批量解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_7 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
      }
else if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("MID")||reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("BASIC"))&&(querySingleInductionRecordIdDetailComRespDto!= null&& querySingleInductionRecordIdDetailComRespDto.getInductionRecordId() != null )){
       //elseif((B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 中层 or B3获取高中基层工作任务场景权限.高/中/基层操作场景 等于 基层) and D1-3-13查当前就职记录是否入参部门直属成员.就职记录ID 值不等于空 )  53602

ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_8 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_7 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_6=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_6.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493159_1_59934
implementConcurrentBehaviorThemeLockComReqDto_6.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1493164_1_59934
implementConcurrentBehaviorThemeLockComReqDto_6.setTimeUnitType("MINUTES");//sourceId:1493165_1_59934
implementConcurrentBehaviorThemeLockComReqDto_6.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1493167_1_59934
implementConcurrentBehaviorThemeLockComReqDto_6.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1493166_1_59934
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_6.setCommPrimaryKey(obtainReceiveFieldComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1493160_1_59934
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_6.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493161_1_59934
    }
if(obtainReceiveFieldComRespDto_7!=null){
      implementConcurrentBehaviorThemeLockComReqDto_6.setCustomField2(obtainReceiveFieldComRespDto_7.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493162_1_59934
    }

    /*D3执行并发行为主题加锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getDuration(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-锁定时长不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getTimeUnitType(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-时间单位类型不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getHandlingMethodConcurrentLockFailure(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_6.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题加锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_8 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_6).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementConcurrentBehaviorThemeLockComRespDto_8!= null&&  implementConcurrentBehaviorThemeLockComRespDto_8.getPreventConcurrentLockingSituations() !=null && implementConcurrentBehaviorThemeLockComRespDto_8.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D3执行并发行为主题加锁（问题）.防并发上锁情况 等于 空上锁成功)  59935

ImplementIniProblemMsgLocationByLoginComRespDto implementIniProblemMsgLocationByLoginComRespDto_1 = null;
    ImplementIniProblemMsgLocationByLoginComReqDto implementIniProblemMsgLocationByLoginComReqDto_1=new ImplementIniProblemMsgLocationByLoginComReqDto();
  implementIniProblemMsgLocationByLoginComReqDto_1.setSurfaceCode("INDUCTION_RECORD");//sourceId:1481728_1_59936
implementIniProblemMsgLocationByLoginComReqDto_1.setEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1481729_1_59936
implementIniProblemMsgLocationByLoginComReqDto_1.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:1312800_1_59936
implementIniProblemMsgLocationByLoginComReqDto_1.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1312801_1_59936
implementIniProblemMsgLocationByLoginComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1312803_1_59936

    /*D2-执行初始化中基层问题消息数量(公共)[7879]   */
    Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto_1.getSurfaceCode(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层问题消息数量(公共)-归属内容类型编码不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto_1.getEntityId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层问题消息数量(公共)-归属内容ID不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto_1.getUserId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层问题消息数量(公共)-账号不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto_1.getOriginalRoleMemberId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层问题消息数量(公共)-身份人员ID不能为空",false);
Assert.isNull(implementIniProblemMsgLocationByLoginComReqDto_1.getSpaceId(),"B3获取高中基层工作任务场景权限-D2-执行初始化中基层问题消息数量(公共)-创建于空间ID不能为空",false);
      implementIniProblemMsgLocationByLoginComRespDto_1 = fwCompMessageClient.implementIniProblemMsgLocationByLoginCom(implementIniProblemMsgLocationByLoginComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_9 = null;
    if(obtainReceiveFieldComRespDto !=null&&obtainReceiveFieldComRespDto_7 !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_7=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_7.setBehaviorThemeLockCode("HIGH_MID_BASE_WORK_TASK_AND_PRO_LOC_MSG_NUMBER_SWIPES");//sourceId:1493170_1_59937
implementConcurrentBehaviorThemeLockComReqDto_7.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1493177_1_59937
implementConcurrentBehaviorThemeLockComReqDto_7.setWhetherUnlockBulk("FALSE");//sourceId:1493180_1_59937
if(obtainReceiveFieldComRespDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_7.setCommPrimaryKey(obtainReceiveFieldComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1493171_1_59937
    }
if(reqDto!=null){
      implementConcurrentBehaviorThemeLockComReqDto_7.setCustomField1(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1493172_1_59937
    }
if(obtainReceiveFieldComRespDto_7!=null){
      implementConcurrentBehaviorThemeLockComReqDto_7.setCustomField2(obtainReceiveFieldComRespDto_7.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1493173_1_59937
    }

    /*D3执行并发行为主题解锁（工作任务或问题）[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_7.getBehaviorThemeLockCode(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_7.getCommPrimaryKey(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_7.getCustomField1(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_7.getCustomField2(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-自定义字段2不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_7.getPreventConcurrentLockingUnlocking(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_7.getWhetherUnlockBulk(),"B3获取高中基层工作任务场景权限-D3执行并发行为主题解锁（工作任务或问题）-是否批量解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_9 = fwAppInterfaceModeClient.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_7).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
    }
    }
BffObtainTopMidBasicScenePowerRespDto retData = new BffObtainTopMidBasicScenePowerRespDto();
  if(obtainReceiveFieldComRespDto_3!=null){
      retData.setMyArrangeWrokTaskPower(obtainReceiveFieldComRespDto_3.getCustomField());//SimpleFieldAssign//sourceId:1998500_1
retData.setAllWorkTaskPower(obtainReceiveFieldComRespDto_3.getCustomField1());//SimpleFieldAssign//sourceId:1998501_1
retData.setMyQuestionPower(obtainReceiveFieldComRespDto_3.getCustomField2());//SimpleFieldAssign//sourceId:1998502_1
retData.setAllQuestionPower(obtainReceiveFieldComRespDto_3.getCustomField3());//SimpleFieldAssign//sourceId:1998503_1
    }




return retData;
  }
/**
   * B3修订独立任务或子任务[8030]
   * gen by moon at 9/5/2024, 10:17:54 PM
   */
    @Trace(operationName = "B3修订独立任务或子任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementUpdateIndependentTaskRespDto implementUpdateIndependentTask(BffImplementUpdateIndependentTaskReqDto reqDto){


       //步骤0: D3执行更新独立任务 - implementUpdateIndependentTask
     ImplementUpdateIndependentTaskRespDto implementUpdateIndependentTaskRespDto = null;
    ImplementUpdateIndependentTaskReqDto implementUpdateIndependentTaskReqDto=new ImplementUpdateIndependentTaskReqDto();
  if(reqDto!=null){
      implementUpdateIndependentTaskReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1356853_1
implementUpdateIndependentTaskReqDto.setTaskNumber(reqDto.getTaskNumber());//SimpleFieldAssign//sourceId:1356854_1
implementUpdateIndependentTaskReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:1356855_1
implementUpdateIndependentTaskReqDto.setTaskDesc(reqDto.getTaskDesc());//SimpleFieldAssign//sourceId:1356856_1
implementUpdateIndependentTaskReqDto.setParentTableTypeCode(reqDto.getParentTableTypeCode());//SimpleFieldAssign//sourceId:1996909_1
implementUpdateIndependentTaskReqDto.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1996910_1
implementUpdateIndependentTaskReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1996911_1
implementUpdateIndependentTaskReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1996912_1
implementUpdateIndependentTaskReqDto.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1400510_1
implementUpdateIndependentTaskReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1996806_1
    }

    /*D3执行更新独立任务[8027]   */
    Assert.isNull(implementUpdateIndependentTaskReqDto.getTaskId(),"B3修订独立任务或子任务-D3执行更新独立任务-任务ID不能为空",false);
      implementUpdateIndependentTaskRespDto = fwAppWorkTasksClient.implementUpdateIndependentTask(implementUpdateIndependentTaskReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementUpdateIndependentTaskRespDto retData = new BffImplementUpdateIndependentTaskRespDto();





return retData;
  }
/**
   * B3执行更新协同任务[8031]
   * gen by moon at 11/30/2023, 8:37:11 PM
   */
    @Trace(operationName = "B3执行更新协同任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementUpdateProjectRespDto implementUpdateProject(BffImplementUpdateProjectReqDto reqDto){


       //步骤0: D3执行更新协同任务 - implementUpdateProject
     ImplementUpdateProjectRespDto implementUpdateProjectRespDto = null;
    ImplementUpdateProjectReqDto implementUpdateProjectReqDto=new ImplementUpdateProjectReqDto();
  if(reqDto!=null){
      implementUpdateProjectReqDto.setProjectId(reqDto.getProjectId());//SimpleFieldAssign//sourceId:1356970_1
implementUpdateProjectReqDto.setProjectNumber(reqDto.getProjectNumber());//SimpleFieldAssign//sourceId:1356971_1
implementUpdateProjectReqDto.setProjectName(reqDto.getProjectName());//SimpleFieldAssign//sourceId:1356972_1
implementUpdateProjectReqDto.setProjectDesc(reqDto.getProjectDesc());//SimpleFieldAssign//sourceId:1356974_1
    }

    /*D3执行更新协同任务[8028]   */
    Assert.isNull(implementUpdateProjectReqDto.getProjectId(),"B3执行更新协同任务-D3执行更新协同任务-项目ID不能为空",false);
      implementUpdateProjectRespDto = fwAppWorkTasksClient.implementUpdateProject(implementUpdateProjectReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementUpdateProjectRespDto retData = new BffImplementUpdateProjectRespDto();





return retData;
  }
/**
   * B3执行内容状态转换[8038]
   * gen by moon at 12/6/2023, 7:53:45 PM
   */
    @Trace(operationName = "B3执行内容状态转换")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementContentStateConversionRespDto implementContentStateConversion(BffImplementContentStateConversionReqDto reqDto){


       ImplementContentStateConversionComRespDto implementContentStateConversionComRespDto_1 =null;
//步骤0: D3执行内容状态转换(公共) - implementContentStateConversionCom
     ImplementContentStateConversionComRespDto implementContentStateConversionComRespDto = null;
    ImplementContentStateConversionComReqDto implementContentStateConversionComReqDto=new ImplementContentStateConversionComReqDto();
  if(reqDto!=null){
      implementContentStateConversionComReqDto.setTaskStatusScreen(reqDto.getTaskStatusScreen());//SimpleFieldAssign//sourceId:1391753_1
      implementContentStateConversionComReqDto.setWorkTaskObjectType(reqDto.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1361882_1
implementContentStateConversionComReqDto.setWorkTaskObjectId(reqDto.getWorkTaskObjectId());//SimpleFieldAssign//sourceId:1361887_1
implementContentStateConversionComReqDto.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1361883_1
implementContentStateConversionComReqDto.setIsComplete(reqDto.getIsComplete());//SimpleFieldAssign//sourceId:1361884_1
implementContentStateConversionComReqDto.setIsOverdue(reqDto.getIsOverdue());//SimpleFieldAssign//sourceId:1361885_1
implementContentStateConversionComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1361886_1
    }

    /*D3执行内容状态转换(公共)[8037]   */
    Assert.isNull(implementContentStateConversionComReqDto.getWorkTaskObjectType(),"B3执行内容状态转换-D3执行内容状态转换(公共)-工作任务对象类型不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getWorkTaskObjectId(),"B3执行内容状态转换-D3执行内容状态转换(公共)-工作任务对象ID不能为空",false);
//Assert.isNull(implementContentStateConversionComReqDto.getTaskStatus(),"B3执行内容状态转换-D3执行内容状态转换(公共)-任务进展状态不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getIsComplete(),"B3执行内容状态转换-D3执行内容状态转换(公共)-是否完成不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getIsOverdue(),"B3执行内容状态转换-D3执行内容状态转换(公共)-是否逾期不能为空",false);
Assert.isNull(implementContentStateConversionComReqDto.getSubjectLifeCycle(),"B3执行内容状态转换-D3执行内容状态转换(公共)-主体生命周期不能为空",false);
      implementContentStateConversionComRespDto = fwAppWorkTasksClient.implementContentStateConversionCom(implementContentStateConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementContentStateConversionComRespDto_1 = implementContentStateConversionComRespDto;

BffImplementContentStateConversionRespDto retData = new BffImplementContentStateConversionRespDto();
  if(implementContentStateConversionComRespDto_1!=null){
      retData.setWorkTaskObjectId(implementContentStateConversionComRespDto_1.getWorkTaskObjectId());//SimpleFieldAssign//sourceId:1361896_1
retData.setStateCode(implementContentStateConversionComRespDto_1.getStateCode());//SimpleFieldAssign//sourceId:1391755_1
    }




return retData;
  }
/**
   * B3-设置工作任务分管领导[8054]
   * gen by moon at 12/7/2023, 2:57:15 PM
   */
    @Trace(operationName = "B3-设置工作任务分管领导")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffSetWorkTaskDeptLeaderRespDto setWorkTaskDeptLeader(BffSetWorkTaskDeptLeaderReqDto reqDto){


       //步骤0: D3-变更分管领导及更新消息位置数量(公共) - implementGenerateDeptLeaderVirtualOrgMemberCom
     ImplementGenerateDeptLeaderVirtualOrgMemberComRespDto implementGenerateDeptLeaderVirtualOrgMemberComRespDto = null;
    ImplementGenerateDeptLeaderVirtualOrgMemberComReqDto implementGenerateDeptLeaderVirtualOrgMemberComReqDto=new ImplementGenerateDeptLeaderVirtualOrgMemberComReqDto();
if(reqDto!=null){
      implementGenerateDeptLeaderVirtualOrgMemberComReqDto.setDeptLeaderInductionId(reqDto.getDeptLeaderInductionId());//SimpleFieldAssign//sourceId:1394236_1
implementGenerateDeptLeaderVirtualOrgMemberComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1394238_1
    }

    /*D3-变更分管领导及更新消息位置数量(公共)[8099]   */
    Assert.isNull(implementGenerateDeptLeaderVirtualOrgMemberComReqDto.getDeptLeaderInductionId(),"B3-设置工作任务分管领导-D3-变更分管领导及更新消息位置数量(公共)-分管领导就职记录ID不能为空",false);
Assert.isNull(implementGenerateDeptLeaderVirtualOrgMemberComReqDto.getEntityId(),"B3-设置工作任务分管领导-D3-变更分管领导及更新消息位置数量(公共)-冗余内容表主键ID不能为空",false);
      implementGenerateDeptLeaderVirtualOrgMemberComRespDto = fwAppVirtualOrgClient.implementGenerateDeptLeaderVirtualOrgMemberCom(implementGenerateDeptLeaderVirtualOrgMemberComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffSetWorkTaskDeptLeaderRespDto retData = new BffSetWorkTaskDeptLeaderRespDto();





return retData;
  }
/**
   * B3查询不同工作任务详情[8069]
   * gen by moon at 12/3/2023, 6:46:02 PM
   */
    @Trace(operationName = "B3查询不同工作任务详情")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryDifferentWorkTasksDetailRespDto queryDifferentWorkTasksDetail(BffQueryDifferentWorkTasksDetailReqDto reqDto){


       QueryDifferentWorkTasksDetailComRespDto queryDifferentWorkTasksDetailComRespDto_1 =null;
//步骤0: D3-查询不同工作任务详情(公共) - queryDifferentWorkTasksDetailCom
     QueryDifferentWorkTasksDetailComRespDto queryDifferentWorkTasksDetailComRespDto = null;
    QueryDifferentWorkTasksDetailComReqDto queryDifferentWorkTasksDetailComReqDto=new QueryDifferentWorkTasksDetailComReqDto();
  if(reqDto!=null){
      queryDifferentWorkTasksDetailComReqDto.setWorkTaskObjectType(reqDto.getWorkTaskObjectType());//SimpleFieldAssign//sourceId:1370922_1
queryDifferentWorkTasksDetailComReqDto.setWorkTaskObjectId(reqDto.getWorkTaskObjectId());//SimpleFieldAssign//sourceId:1370923_1
queryDifferentWorkTasksDetailComReqDto.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1370936_1
    }

    /*D3-查询不同工作任务详情(公共)[7824]   */
    Assert.isNull(queryDifferentWorkTasksDetailComReqDto.getWorkTaskObjectType(),"B3查询不同工作任务详情-D3-查询不同工作任务详情(公共)-工作任务对象类型不能为空",false);
      queryDifferentWorkTasksDetailComRespDto = fwAppWorkTasksClient.queryDifferentWorkTasksDetailCom(queryDifferentWorkTasksDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryDifferentWorkTasksDetailComRespDto_1 = queryDifferentWorkTasksDetailComRespDto;

BffQueryDifferentWorkTasksDetailRespDto retData = new BffQueryDifferentWorkTasksDetailRespDto();
  if(queryDifferentWorkTasksDetailComRespDto_1!=null){
      retData.setTaskId(queryDifferentWorkTasksDetailComRespDto_1.getTaskId());//SimpleFieldAssign//sourceId:1375455_1
retData.setTaskName(queryDifferentWorkTasksDetailComRespDto_1.getTaskName());//SimpleFieldAssign//sourceId:1375456_1
retData.setTotalLength(queryDifferentWorkTasksDetailComRespDto_1.getTotalLength());//SimpleFieldAssign//sourceId:1375457_1
retData.setArrangeSubjectId(queryDifferentWorkTasksDetailComRespDto_1.getArrangeSubjectId());//SimpleFieldAssign//sourceId:1375458_1
retData.setArrangeSubjectTypeCode(queryDifferentWorkTasksDetailComRespDto_1.getArrangeSubjectTypeCode());//SimpleFieldAssign//sourceId:1375459_1
retData.setReceiveSubjectId(queryDifferentWorkTasksDetailComRespDto_1.getReceiveSubjectId());//SimpleFieldAssign//sourceId:1375460_1
retData.setIsComplete(queryDifferentWorkTasksDetailComRespDto_1.getIsComplete());//SimpleFieldAssign//sourceId:1375461_1
retData.setIsOverdue(queryDifferentWorkTasksDetailComRespDto_1.getIsOverdue());//SimpleFieldAssign//sourceId:1375462_1
retData.setTaskStatus(queryDifferentWorkTasksDetailComRespDto_1.getTaskStatus());//SimpleFieldAssign//sourceId:1375463_1
retData.setPlanStartTime(queryDifferentWorkTasksDetailComRespDto_1.getPlanStartTime());//SimpleFieldAssign//sourceId:1375464_1
retData.setPlanEndTime(queryDifferentWorkTasksDetailComRespDto_1.getPlanEndTime());//SimpleFieldAssign//sourceId:1375465_1
retData.setActualEndTime(queryDifferentWorkTasksDetailComRespDto_1.getActualEndTime());//SimpleFieldAssign//sourceId:1375466_1
retData.setTableTypeCode(queryDifferentWorkTasksDetailComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:1375467_1
retData.setEntityId(queryDifferentWorkTasksDetailComRespDto_1.getEntityId());//SimpleFieldAssign//sourceId:1375468_1
retData.setParentTableTypeCode(queryDifferentWorkTasksDetailComRespDto_1.getParentTableTypeCode());//SimpleFieldAssign//sourceId:1375469_1
retData.setParentEntityId(queryDifferentWorkTasksDetailComRespDto_1.getParentEntityId());//SimpleFieldAssign//sourceId:1375470_1
retData.setThemeContentTypeCode(queryDifferentWorkTasksDetailComRespDto_1.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1375471_1
retData.setThemeContentId(queryDifferentWorkTasksDetailComRespDto_1.getThemeContentId());//SimpleFieldAssign//sourceId:1375472_1
retData.setObjectTypeCode(queryDifferentWorkTasksDetailComRespDto_1.getObjectTypeCode());//SimpleFieldAssign//sourceId:1375473_1
retData.setObjectId(queryDifferentWorkTasksDetailComRespDto_1.getObjectId());//SimpleFieldAssign//sourceId:1375474_1
retData.setSubjectLifeCycle(queryDifferentWorkTasksDetailComRespDto_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1375475_1
retData.setCreateInductionId(queryDifferentWorkTasksDetailComRespDto_1.getCreateInductionId());//SimpleFieldAssign//sourceId:1375476_1
retData.setSpaceId(queryDifferentWorkTasksDetailComRespDto_1.getSpaceId());//SimpleFieldAssign//sourceId:1375477_1
retData.setAppId(queryDifferentWorkTasksDetailComRespDto_1.getAppId());//SimpleFieldAssign//sourceId:1375478_1
    }




return retData;
  }
/**
   * B3执行签收动态操作权限判断[8120]
   * gen by moon at 12/10/2023, 4:14:16 PM
   */
    @Trace(operationName = "B3执行签收动态操作权限判断")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementDynamicOptPermissionJudgmentReceiptSignRespDto implementDynamicOptPermissionJudgmentReceiptSign(BffImplementDynamicOptPermissionJudgmentReceiptSignReqDto reqDto){


       ImplementDynamicOptPermissionJudgmentReceiptSignRespDto implementDynamicOptPermissionJudgmentReceiptSignRespDto_1 =null;
//步骤0: D3执行签收动态操作权限判断 - implementDynamicOptPermissionJudgmentReceiptSign
     ImplementDynamicOptPermissionJudgmentReceiptSignRespDto implementDynamicOptPermissionJudgmentReceiptSignRespDto = null;
    ImplementDynamicOptPermissionJudgmentReceiptSignReqDto implementDynamicOptPermissionJudgmentReceiptSignReqDto=new ImplementDynamicOptPermissionJudgmentReceiptSignReqDto();
  implementDynamicOptPermissionJudgmentReceiptSignReqDto.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:1401538_1
implementDynamicOptPermissionJudgmentReceiptSignReqDto.setMessageTemplateCode("GENERATE_TO_BE_SIGNED_WORK_TASK_MSG_TEMP");//CUSTOM_CONVENTION//sourceId:1401502_1
if(reqDto!=null){
      implementDynamicOptPermissionJudgmentReceiptSignReqDto.setMessageId(reqDto.getMessageId());//SimpleFieldAssign//sourceId:1401503_1
implementDynamicOptPermissionJudgmentReceiptSignReqDto.setIsHandle(reqDto.getIsHandle());//SimpleFieldAssign//sourceId:1401504_1
implementDynamicOptPermissionJudgmentReceiptSignReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1401500_1
    }

    /*D3执行签收动态操作权限判断[8119]   */
    Assert.isNull(implementDynamicOptPermissionJudgmentReceiptSignReqDto.getMessageId(),"B3执行签收动态操作权限判断-D3执行签收动态操作权限判断-消息ID不能为空",false);
Assert.isNull(implementDynamicOptPermissionJudgmentReceiptSignReqDto.getEntityId(),"B3执行签收动态操作权限判断-D3执行签收动态操作权限判断-内容表主键ID不能为空",false);
Assert.isNull(implementDynamicOptPermissionJudgmentReceiptSignReqDto.getOriginalRoleMemberId(),"B3执行签收动态操作权限判断-D3执行签收动态操作权限判断-身份人员ID不能为空",false);
Assert.isNull(implementDynamicOptPermissionJudgmentReceiptSignReqDto.getMessageTemplateCode(),"B3执行签收动态操作权限判断-D3执行签收动态操作权限判断-消息模板标识不能为空",false);
      implementDynamicOptPermissionJudgmentReceiptSignRespDto = fwAppWorkTasksClient.implementDynamicOptPermissionJudgmentReceiptSign(implementDynamicOptPermissionJudgmentReceiptSignReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementDynamicOptPermissionJudgmentReceiptSignRespDto_1 = implementDynamicOptPermissionJudgmentReceiptSignRespDto;

BffImplementDynamicOptPermissionJudgmentReceiptSignRespDto retData = new BffImplementDynamicOptPermissionJudgmentReceiptSignRespDto();
  if(implementDynamicOptPermissionJudgmentReceiptSignRespDto_1!=null){
      retData.setMessageId(implementDynamicOptPermissionJudgmentReceiptSignRespDto_1.getMessageId());//SimpleFieldAssign//sourceId:1401510_1
retData.setIsHandle(implementDynamicOptPermissionJudgmentReceiptSignRespDto_1.getIsHandle());//SimpleFieldAssign//sourceId:1401511_1
    }




return retData;
  }
/**
   * B3-查询工作任务来源列表（新）[8154]
   * gen by moon at 12/17/2023, 12:32:45 PM
   */
    @Trace(operationName = "B3-查询工作任务来源列表（新）")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQuerySourceOfWorkTaskNewListRespDto querySourceOfWorkTaskNewList(BffQuerySourceOfWorkTaskNewListReqDto reqDto){


       QuerySourceOfWorkTaskListRespDto querySourceOfWorkTaskListRespDto_1 =null;
//步骤0: D3查询工作任务来源列表 - querySourceOfWorkTaskList
     QuerySourceOfWorkTaskListRespDto querySourceOfWorkTaskListRespDto = null;
    QuerySourceOfWorkTaskListReqDto querySourceOfWorkTaskListReqDto=new QuerySourceOfWorkTaskListReqDto();
  if(reqDto!=null){
      querySourceOfWorkTaskListReqDto.setSourceTypeCode(reqDto.getSourceTypeCode());//SimpleFieldAssign//sourceId:1420147_1
    }

    /*D3查询工作任务来源列表[8155]   */

      querySourceOfWorkTaskListRespDto = fwAppWorkTasksClient.querySourceOfWorkTaskList(querySourceOfWorkTaskListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      querySourceOfWorkTaskListRespDto_1 = querySourceOfWorkTaskListRespDto;

BffQuerySourceOfWorkTaskNewListRespDto retData = new BffQuerySourceOfWorkTaskNewListRespDto();
  if(querySourceOfWorkTaskListRespDto_1!=null){
      retData.setWorkTaskSourceList(querySourceOfWorkTaskListRespDto_1.getWorkTaskSourceList().stream().map(item -> BeanUtil.toBean(item, BffWorkTaskSourceDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1420149_1
    }




return retData;
  }
/**
   * B3查工作任务管理筛选条件列表[8157]
   * gen by moon at 12/18/2023, 9:44:22 PM
   */
    @Trace(operationName = "B3查工作任务管理筛选条件列表")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryWorkTaskMgtScreenConditionListRespDto queryWorkTaskMgtScreenConditionList(BffQueryWorkTaskMgtScreenConditionListReqDto reqDto){


       QueryWorkTaskMgtScreenConditionListRespDto queryWorkTaskMgtScreenConditionListRespDto_1 =null;
//步骤0: D3查工作任务管理筛选条件列表 - queryWorkTaskMgtScreenConditionList
     QueryWorkTaskMgtScreenConditionListRespDto queryWorkTaskMgtScreenConditionListRespDto = null;
    QueryWorkTaskMgtScreenConditionListReqDto queryWorkTaskMgtScreenConditionListReqDto=new QueryWorkTaskMgtScreenConditionListReqDto();
  if(reqDto!=null){
      queryWorkTaskMgtScreenConditionListReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1421054_1
queryWorkTaskMgtScreenConditionListReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1426355_1
    }

    /*D3查工作任务管理筛选条件列表[8158]   */

      queryWorkTaskMgtScreenConditionListRespDto = fwAppWorkTasksClient.queryWorkTaskMgtScreenConditionList(queryWorkTaskMgtScreenConditionListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryWorkTaskMgtScreenConditionListRespDto_1 = queryWorkTaskMgtScreenConditionListRespDto;

BffQueryWorkTaskMgtScreenConditionListRespDto retData = new BffQueryWorkTaskMgtScreenConditionListRespDto();
  if(queryWorkTaskMgtScreenConditionListRespDto_1!=null){
      retData.setWorkTaskMgtScreenConditionList(queryWorkTaskMgtScreenConditionListRespDto_1.getWorkTaskMgtScreenConditionList().stream().map(item -> BeanUtil.toBean(item, BffWorkTaskMgtScreenConditionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1421056_1
retData.setTaskStatusList(queryWorkTaskMgtScreenConditionListRespDto_1.getTaskStatusList().stream().map(item -> BeanUtil.toBean(item, BffTaskStatusDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1421066_1
retData.setDeptId(queryWorkTaskMgtScreenConditionListRespDto_1.getDeptId());//SimpleFieldAssign//sourceId:1427924_1
    }




return retData;
  }
/**
   * B3执行提前开始工作任务[8275]
   * gen by moon at 1/6/2024, 11:51:46 PM
   */
    @Trace(operationName = "B3执行提前开始工作任务")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffImplementStartWorkTasksAheadScheduleRespDto implementStartWorkTasksAheadSchedule(BffImplementStartWorkTasksAheadScheduleReqDto reqDto){


       //步骤0: D3执行提前开始工作任务(公共) - implementStartWorkTasksAheadScheduleCom
     ImplementStartWorkTasksAheadScheduleComRespDto implementStartWorkTasksAheadScheduleComRespDto = null;
    ImplementStartWorkTasksAheadScheduleComReqDto implementStartWorkTasksAheadScheduleComReqDto=new ImplementStartWorkTasksAheadScheduleComReqDto();
  if(reqDto!=null){
      implementStartWorkTasksAheadScheduleComReqDto.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1475492_1
      implementStartWorkTasksAheadScheduleComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1471860_1
implementStartWorkTasksAheadScheduleComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1471861_1
implementStartWorkTasksAheadScheduleComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1471862_1
    }

    /*D3执行提前开始工作任务(公共)[8274]   */
    Assert.isNull(implementStartWorkTasksAheadScheduleComReqDto.getCustomField(),"B3执行提前开始工作任务-D3执行提前开始工作任务(公共)-自定义字段不能为空",false);
    Assert.isNull(implementStartWorkTasksAheadScheduleComReqDto.getTaskId(),"B3执行提前开始工作任务-D3执行提前开始工作任务(公共)-任务ID不能为空",false);
      implementStartWorkTasksAheadScheduleComRespDto = fwAppWorkTasksClient.implementStartWorkTasksAheadScheduleCom(implementStartWorkTasksAheadScheduleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




BffImplementStartWorkTasksAheadScheduleRespDto retData = new BffImplementStartWorkTasksAheadScheduleRespDto();





return retData;
  }
/**
   * B3查询工作任务详情[8350]
   * gen by moon at 1/25/2024, 8:13:06 PM
   */
    @Trace(operationName = "B3查询工作任务详情")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryWorkTaskDetailRespDto queryWorkTaskDetail(BffQueryWorkTaskDetailReqDto reqDto){


       QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto_1 =null;
//步骤0: D3查询独立任务详情(公共) - queryIndependentTaskDetailCom
     QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto = null;
    QueryIndependentTaskDetailComReqDto queryIndependentTaskDetailComReqDto=new QueryIndependentTaskDetailComReqDto();
  queryIndependentTaskDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1506760_1
if(reqDto!=null){
      queryIndependentTaskDetailComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1506758_1
    }

    /*D3查询独立任务详情(公共)[7793]   */
    Assert.isNull(queryIndependentTaskDetailComReqDto.getTaskId(),"B3查询工作任务详情-D3查询独立任务详情(公共)-任务ID不能为空",false);
Assert.isNull(queryIndependentTaskDetailComReqDto.getSpaceId(),"B3查询工作任务详情-D3查询独立任务详情(公共)-创建于空间ID不能为空",false);
      queryIndependentTaskDetailComRespDto = fwAppWorkTasksClient.queryIndependentTaskDetailCom(queryIndependentTaskDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryIndependentTaskDetailComRespDto_1 = queryIndependentTaskDetailComRespDto;

BffQueryWorkTaskDetailRespDto retData = new BffQueryWorkTaskDetailRespDto();
  if(queryIndependentTaskDetailComRespDto_1!=null){
      retData.setTaskId(queryIndependentTaskDetailComRespDto_1.getTaskId());//SimpleFieldAssign//sourceId:1506822_1
retData.setTaskName(queryIndependentTaskDetailComRespDto_1.getTaskName());//SimpleFieldAssign//sourceId:1506823_1
retData.setTaskType(queryIndependentTaskDetailComRespDto_1.getTaskType());//SimpleFieldAssign//sourceId:1506824_1
      retData.setWorkTaskType(queryIndependentTaskDetailComRespDto_1.getWorkTaskType());
    }




return retData;
  }
/**
   * B3查询任务分类周期主题列表(管理)[8996]
   * gen by moon at 7/24/2024, 10:18:53 PM
   */
    @Trace(operationName = "B3查询任务分类周期主题列表(管理)")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryTaskCategoriesCycleThemeListRespDto queryTaskCategoriesCycleThemeList(BffQueryTaskCategoriesCycleThemeListReqDto reqDto){


       QueryTaskCategoriesCycleThemeListRespDto queryTaskCategoriesCycleThemeListRespDto_1 =null;
//步骤0: D3查询任务分类周期主题列表 - queryTaskCategoriesCycleThemeList
     QueryTaskCategoriesCycleThemeListRespDto queryTaskCategoriesCycleThemeListRespDto = null;
    QueryTaskCategoriesCycleThemeListReqDto queryTaskCategoriesCycleThemeListReqDto=new QueryTaskCategoriesCycleThemeListReqDto();


    /*D3查询任务分类周期主题列表[10046]   */

      queryTaskCategoriesCycleThemeListRespDto = fwAppWorkTasksClient.queryTaskCategoriesCycleThemeList(queryTaskCategoriesCycleThemeListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryTaskCategoriesCycleThemeListRespDto_1 = queryTaskCategoriesCycleThemeListRespDto;

BffQueryTaskCategoriesCycleThemeListRespDto retData = new BffQueryTaskCategoriesCycleThemeListRespDto();
  if(queryTaskCategoriesCycleThemeListRespDto_1!=null){
      retData.setTaskCategoriesThemeList(queryTaskCategoriesCycleThemeListRespDto_1.getTaskCategoriesThemeList().stream().map(item -> BeanUtil.toBean(item, BffTaskCategoriesThemeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1953792_1
    }




return retData;
  }
/**
   * B3查询指标下对齐的工作任务列表[10206]
   * gen by moon at 9/15/2024, 7:31:54 PM
   */
    @Trace(operationName = "B3查询指标下对齐的工作任务列表")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryObjectiveAlignmentWorkTaskListRespDto queryObjectiveAlignmentWorkTaskList(BffQueryObjectiveAlignmentWorkTaskListReqDto reqDto){


       QueryTimeStatisticsTasksListComRespDto queryTimeStatisticsTasksListComRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_1 =null;
//步骤0: D3查询时间统计任务列表(公共) - queryTimeStatisticsTasksListCom
     QueryTimeStatisticsTasksListComRespDto queryTimeStatisticsTasksListComRespDto = null;
    QueryTimeStatisticsTasksListComReqDto queryTimeStatisticsTasksListComReqDto=new QueryTimeStatisticsTasksListComReqDto();
  queryTimeStatisticsTasksListComReqDto.setBizSceneCode("WORK_TASK");//CUSTOM_CONVENTION//sourceId:2002187_1
queryTimeStatisticsTasksListComReqDto.setIsAlignment("TRUE");//sourceId:2002188_1
queryTimeStatisticsTasksListComReqDto.setIsArchive("FALSE");//sourceId:2002274_1
queryTimeStatisticsTasksListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2002193_1
  if(reqDto!=null){
      queryTimeStatisticsTasksListComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:2002273_1
queryTimeStatisticsTasksListComReqDto.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:2002182_1
queryTimeStatisticsTasksListComReqDto.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:2002183_1
    }

    /*D3查询时间统计任务列表(公共)[10075]   */
    Assert.isNull(queryTimeStatisticsTasksListComReqDto.getObjectiveId(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-对齐指标ID不能为空",false);
Assert.isNull(queryTimeStatisticsTasksListComReqDto.getPlanStartTime(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-计划开始时间不能为空",false);
Assert.isNull(queryTimeStatisticsTasksListComReqDto.getPlanEndTime(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-计划结束时间不能为空",false);
Assert.isNull(queryTimeStatisticsTasksListComReqDto.getBizSceneCode(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-业务场景编码不能为空",false);
Assert.isNull(queryTimeStatisticsTasksListComReqDto.getIsAlignment(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-是否对齐不能为空",false);
Assert.isNull(queryTimeStatisticsTasksListComReqDto.getIsArchive(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-是否存档不能为空",false);
Assert.isNull(queryTimeStatisticsTasksListComReqDto.getSpaceId(),"B3查询指标下对齐的工作任务列表-D3查询时间统计任务列表(公共)-创建于空间ID不能为空",false);
      queryTimeStatisticsTasksListComRespDto = fwAppDashboardWorkTaskClient.queryTimeStatisticsTasksListCom(queryTimeStatisticsTasksListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryTimeStatisticsTasksListComRespDto_1 = queryTimeStatisticsTasksListComRespDto;

//步骤1: D1-3批量查询就职记录列表（公共） - batchQueryInductionRecordListCom
     BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto = null;
    if(queryTimeStatisticsTasksListComRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto=new BatchQueryInductionRecordListComReqDto();
  if(queryTimeStatisticsTasksListComRespDto!= null&&  queryTimeStatisticsTasksListComRespDto.getTaskDataList() !=null&& !CollectionUtil.isEmpty(queryTimeStatisticsTasksListComRespDto.getTaskDataList())){
      batchQueryInductionRecordListComReqDto.setPerOrgInductionRecordList(queryTimeStatisticsTasksListComRespDto.getTaskDataList().stream().map(item->item.getCreateInductionId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1993045_1
    }

    /*D1-3批量查询就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_1 = batchQueryInductionRecordListComRespDto;
           }

BffQueryObjectiveAlignmentWorkTaskListRespDto retData = new BffQueryObjectiveAlignmentWorkTaskListRespDto();
  //数据集融合  MoreListToOneSource
        if(queryTimeStatisticsTasksListComRespDto_1!= null && !CollectionUtil.isEmpty(queryTimeStatisticsTasksListComRespDto_1.getTaskDataList()) ){
          for (TaskDataDto taskDataDto : queryTimeStatisticsTasksListComRespDto_1.getTaskDataList()) {
              BffWorkTaskDto retElm = new BffWorkTaskDto();
             if(queryTimeStatisticsTasksListComRespDto_1!=null){
      retElm.setTaskId(taskDataDto.getTaskId());//SimpleFieldAssign//sourceId:418235_2
retElm.setTaskNumber(taskDataDto.getTaskNumber());//SimpleFieldAssign//sourceId:418236_2
retElm.setTaskName(taskDataDto.getTaskName());//SimpleFieldAssign//sourceId:418237_2
retElm.setTaskType(taskDataDto.getTaskType());//SimpleFieldAssign//sourceId:418238_2
retElm.setPercentageProgress(taskDataDto.getPercentageProgress());//SimpleFieldAssign//sourceId:418239_2
retElm.setCreateInductionId(taskDataDto.getCreateInductionId());//SimpleFieldAssign//sourceId:418240_2
retElm.setCreateTime(taskDataDto.getCreateTime());//SimpleFieldAssign//sourceId:418241_2
    }
              retData.getWorkTaskList().add(retElm);
               if(batchQueryInductionRecordListComRespDto_1!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_1.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(taskDataDto.getCreateInductionId())) {
                 if(batchQueryInductionRecordListComRespDto_1!=null){
      retElm.setIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:418242_2
retElm.setNickName(perOrgInductionRecordDto.getNickName());//SimpleFieldAssign//sourceId:418243_2
retElm.setUserFace(perOrgInductionRecordDto.getUserFace());//SimpleFieldAssign//sourceId:418244_2
retElm.setDeptShortName(perOrgInductionRecordDto.getDeptShortName());//SimpleFieldAssign//sourceId:418245_2
    }
                }
            }
          }

          }
        }//sourceId:2002278_1




return retData;
  }
/**
   * B3查询工作任务单条详情[10220]
   * gen by moon at 9/19/2024, 3:11:41 PM
   */
    @Trace(operationName = "B3查询工作任务单条详情")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryWorkTaskSingleDetailRespDto queryWorkTaskSingleDetail(BffQueryWorkTaskSingleDetailReqDto reqDto){


       QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto_1 =null;
AnalysisWorkTaskAlignmentTargetContentCycleComRespDto analysisWorkTaskAlignmentTargetContentCycleComRespDto_1 =null;
QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto_1 =null;
//步骤0: D3查询独立任务详情(公共) - queryIndependentTaskDetailCom
     QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto = null;
    QueryIndependentTaskDetailComReqDto queryIndependentTaskDetailComReqDto=new QueryIndependentTaskDetailComReqDto();
  queryIndependentTaskDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2001246_1
if(reqDto!=null){
      queryIndependentTaskDetailComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:2001244_1
    }

    /*D3查询独立任务详情(公共)[7793]   */
    Assert.isNull(queryIndependentTaskDetailComReqDto.getTaskId(),"B3查询工作任务单条详情-D3查询独立任务详情(公共)-任务ID不能为空",false);
Assert.isNull(queryIndependentTaskDetailComReqDto.getSpaceId(),"B3查询工作任务单条详情-D3查询独立任务详情(公共)-创建于空间ID不能为空",false);
      queryIndependentTaskDetailComRespDto = fwAppWorkTasksClient.queryIndependentTaskDetailCom(queryIndependentTaskDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryIndependentTaskDetailComRespDto_1 = queryIndependentTaskDetailComRespDto;

//步骤1: D3分析工作任务对齐目标树类型(公共) - analysisWorkTaskAlignmentTargetTreeTypeCom
     AnalysisWorkTaskAlignmentTargetTreeTypeComRespDto analysisWorkTaskAlignmentTargetTreeTypeComRespDto = null;
    AnalysisWorkTaskAlignmentTargetTreeTypeComReqDto analysisWorkTaskAlignmentTargetTreeTypeComReqDto=new AnalysisWorkTaskAlignmentTargetTreeTypeComReqDto();


    /*D3分析工作任务对齐目标树类型(公共)[10235]   */

      analysisWorkTaskAlignmentTargetTreeTypeComRespDto = fwAppWorkTasksClient.analysisWorkTaskAlignmentTargetTreeTypeCom(analysisWorkTaskAlignmentTargetTreeTypeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D3分析工作任务对齐的目标内容周期(公共) - analysisWorkTaskAlignmentTargetContentCycleCom
     AnalysisWorkTaskAlignmentTargetContentCycleComRespDto analysisWorkTaskAlignmentTargetContentCycleComRespDto = null;
    if(analysisWorkTaskAlignmentTargetTreeTypeComRespDto !=null){
    AnalysisWorkTaskAlignmentTargetContentCycleComReqDto analysisWorkTaskAlignmentTargetContentCycleComReqDto=new AnalysisWorkTaskAlignmentTargetContentCycleComReqDto();
  analysisWorkTaskAlignmentTargetContentCycleComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2004677_1
if(analysisWorkTaskAlignmentTargetTreeTypeComRespDto!=null){
      analysisWorkTaskAlignmentTargetContentCycleComReqDto.setEvaObjTypeCode(analysisWorkTaskAlignmentTargetTreeTypeComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2006705_1
    }
if(reqDto!=null){
      analysisWorkTaskAlignmentTargetContentCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2006706_1
    }
if(queryIndependentTaskDetailComRespDto!=null){
      analysisWorkTaskAlignmentTargetContentCycleComReqDto.setTargetCycleContentId(queryIndependentTaskDetailComRespDto.getObjectiveId());//SimpleFieldAssign//sourceId:2006707_1
    }

    /*D3分析工作任务对齐的目标内容周期(公共)[10233]   */
    Assert.isNull(analysisWorkTaskAlignmentTargetContentCycleComReqDto.getEvaObjTypeCode(),"B3查询工作任务单条详情-D3分析工作任务对齐的目标内容周期(公共)-被评对象类型编码不能为空",false);
Assert.isNull(analysisWorkTaskAlignmentTargetContentCycleComReqDto.getCycleId(),"B3查询工作任务单条详情-D3分析工作任务对齐的目标内容周期(公共)-归属周期ID不能为空",false);
Assert.isNull(analysisWorkTaskAlignmentTargetContentCycleComReqDto.getTargetCycleContentId(),"B3查询工作任务单条详情-D3分析工作任务对齐的目标内容周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisWorkTaskAlignmentTargetContentCycleComReqDto.getSpaceId(),"B3查询工作任务单条详情-D3分析工作任务对齐的目标内容周期(公共)-创建于空间ID不能为空",false);
      analysisWorkTaskAlignmentTargetContentCycleComRespDto = fwAppWorkTasksClient.analysisWorkTaskAlignmentTargetContentCycleCom(analysisWorkTaskAlignmentTargetContentCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      analysisWorkTaskAlignmentTargetContentCycleComRespDto_1 = analysisWorkTaskAlignmentTargetContentCycleComRespDto;
           }

//步骤3: D3-查询虚拟组织成员详情(公共) - queryVirtualOrgMemberDetailCom
     QueryVirtualOrgMemberDetailComRespDto queryVirtualOrgMemberDetailComRespDto = null;
    QueryVirtualOrgMemberDetailComReqDto queryVirtualOrgMemberDetailComReqDto=new QueryVirtualOrgMemberDetailComReqDto();
  queryVirtualOrgMemberDetailComReqDto.setIsPersonCharge("TRUE");//sourceId:2001409_1
queryVirtualOrgMemberDetailComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:2001412_1
queryVirtualOrgMemberDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2001411_1
if(reqDto!=null){
      queryVirtualOrgMemberDetailComReqDto.setEntityId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:2001408_1
    }

    /*D3-查询虚拟组织成员详情(公共)[5937]   */
    Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getEntityId(),"B3查询工作任务单条详情-D3-查询虚拟组织成员详情(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getIsPersonCharge(),"B3查询工作任务单条详情-D3-查询虚拟组织成员详情(公共)-是否负责人不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getUseScene(),"B3查询工作任务单条详情-D3-查询虚拟组织成员详情(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getSubjectLifeCycle(),"B3查询工作任务单条详情-D3-查询虚拟组织成员详情(公共)-主体生命周期不能为空",false);
      queryVirtualOrgMemberDetailComRespDto = fwAppVirtualOrgClient.queryVirtualOrgMemberDetailCom(queryVirtualOrgMemberDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤4: D1-3查询个人就职记录信息详情（公共） - queryInductionRecordInfoDetailCom
     QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
    if(queryVirtualOrgMemberDetailComRespDto !=null){
          QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto=new QueryInductionRecordInfoDetailComReqDto();
  queryInductionRecordInfoDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2001421_1
if(queryVirtualOrgMemberDetailComRespDto!=null){
      queryInductionRecordInfoDetailComReqDto.setInductionRecordId(queryVirtualOrgMemberDetailComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:2001413_1
    }

    /*D1-3查询个人就职记录信息详情（公共）[715]   */
    Assert.isNull(queryInductionRecordInfoDetailComReqDto.getInductionRecordId(),"B3查询工作任务单条详情-D1-3查询个人就职记录信息详情（公共）-就职记录ID不能为空",false);
Assert.isNull(queryInductionRecordInfoDetailComReqDto.getSpaceId(),"B3查询工作任务单条详情-D1-3查询个人就职记录信息详情（公共）-创建于空间ID不能为空",false);
      queryInductionRecordInfoDetailComRespDto = fwBaseInductionRecordClient.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryInductionRecordInfoDetailComRespDto_1 = queryInductionRecordInfoDetailComRespDto;
           }

BffQueryWorkTaskSingleDetailRespDto retData = new BffQueryWorkTaskSingleDetailRespDto();
  if(queryIndependentTaskDetailComRespDto_1!=null){
      retData.setTaskId(queryIndependentTaskDetailComRespDto_1.getTaskId());//SimpleFieldAssign//sourceId:2001376_1
retData.setTaskName(queryIndependentTaskDetailComRespDto_1.getTaskName());//SimpleFieldAssign//sourceId:2002121_1
retData.setPercentageProgress(queryIndependentTaskDetailComRespDto_1.getPercentageProgress());//SimpleFieldAssign//sourceId:2001433_1
    }
if(queryInductionRecordInfoDetailComRespDto_1!=null){
      retData.setIdCardName(queryInductionRecordInfoDetailComRespDto_1.getIdCardName());//SimpleFieldAssign//sourceId:2001425_1
retData.setNickName(queryInductionRecordInfoDetailComRespDto_1.getNickName());//SimpleFieldAssign//sourceId:2001426_1
retData.setUserFace(queryInductionRecordInfoDetailComRespDto_1.getUserFace());//SimpleFieldAssign//sourceId:2001427_1
retData.setDeptShortName(queryInductionRecordInfoDetailComRespDto_1.getDeptShortName());//SimpleFieldAssign//sourceId:2001429_1
    }
if(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1!=null){
      retData.setEvaObjTargetCycleId(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2006716_1
retData.setEvaObjTargetCycleCode(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2006717_1
retData.setCyclelAlias(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getCyclelAlias());//SimpleFieldAssign//sourceId:2006718_1
retData.setTargetCycleContentId(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2006719_1
    retData.setTargetCycleContentTypeCode(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getTargetCycleContentTypeCode());
retData.setCycleId(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:2006720_1
retData.setCycleStartTime(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:2006721_1
retData.setCycleEndTime(analysisWorkTaskAlignmentTargetContentCycleComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:2006722_1
    }




return retData;
  }
/**
   * B3查询工作任务汇报资料列表[10225]
   * gen by moon at 9/16/2024, 12:07:26 PM
   */
    @Trace(operationName = "B3查询工作任务汇报资料列表")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryWorkTaskReportStageDataListRespDto queryWorkTaskReportStageDataList(BffQueryWorkTaskReportStageDataListReqDto reqDto){


       QueryWorkTaskReportStageDataListRespDto queryWorkTaskReportStageDataListRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_1 =null;
BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_3 =null;
//步骤0: D3查询工作任务汇报资料列表 - queryWorkTaskReportStageDataList
     QueryWorkTaskReportStageDataListRespDto queryWorkTaskReportStageDataListRespDto = null;
    QueryWorkTaskReportStageDataListReqDto queryWorkTaskReportStageDataListReqDto=new QueryWorkTaskReportStageDataListReqDto();
  queryWorkTaskReportStageDataListReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2001909_1
if(reqDto!=null){
      queryWorkTaskReportStageDataListReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:2001908_1
    }

    /*D3查询工作任务汇报资料列表[10222]   */
    Assert.isNull(queryWorkTaskReportStageDataListReqDto.getTaskId(),"B3查询工作任务汇报资料列表-D3查询工作任务汇报资料列表-任务ID不能为空",false);
Assert.isNull(queryWorkTaskReportStageDataListReqDto.getSpaceId(),"B3查询工作任务汇报资料列表-D3查询工作任务汇报资料列表-创建于空间ID不能为空",false);
      queryWorkTaskReportStageDataListRespDto = fwAppWorkTasksClient.queryWorkTaskReportStageDataList(queryWorkTaskReportStageDataListReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryWorkTaskReportStageDataListRespDto_1 = queryWorkTaskReportStageDataListRespDto;

//步骤1: D1-3批量查询就职记录列表（公共） - batchQueryInductionRecordListCom
     BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto = null;
    if(queryWorkTaskReportStageDataListRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto=new BatchQueryInductionRecordListComReqDto();
  if(queryWorkTaskReportStageDataListRespDto!= null&&  queryWorkTaskReportStageDataListRespDto.getCycleStageDataList() !=null&& !CollectionUtil.isEmpty(queryWorkTaskReportStageDataListRespDto.getCycleStageDataList())){
      batchQueryInductionRecordListComReqDto.setPerOrgInductionRecordList(queryWorkTaskReportStageDataListRespDto.getCycleStageDataList().stream().map(item->item.getFilledByInductionId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2001918_1
    }

    /*D1-3批量查询任务责任人就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_1 = batchQueryInductionRecordListComRespDto;
           }

//步骤2: D1-3批量查询就职记录列表（公共） - batchQueryInductionRecordListCom
     BatchQueryInductionRecordListComRespDto batchQueryInductionRecordListComRespDto_2 = null;
    if(queryWorkTaskReportStageDataListRespDto !=null){
          BatchQueryInductionRecordListComReqDto batchQueryInductionRecordListComReqDto_1=new BatchQueryInductionRecordListComReqDto();
  if(queryWorkTaskReportStageDataListRespDto!= null&&  queryWorkTaskReportStageDataListRespDto.getCycleStageDataList() !=null&& !CollectionUtil.isEmpty(queryWorkTaskReportStageDataListRespDto.getCycleStageDataList())){
      batchQueryInductionRecordListComReqDto_1.setPerOrgInductionRecordList(queryWorkTaskReportStageDataListRespDto.getCycleStageDataList().stream().map(item->item.getOperationInductionId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2001914_1
    }

    /*D1-3批量查询操作人就职记录列表（公共）[602]   */

      batchQueryInductionRecordListComRespDto_2 = fwBaseInductionRecordClient.batchQueryInductionRecordListCom(batchQueryInductionRecordListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryInductionRecordListComRespDto_3 = batchQueryInductionRecordListComRespDto_2;
           }

BffQueryWorkTaskReportStageDataListRespDto retData = new BffQueryWorkTaskReportStageDataListRespDto();
  //数据集融合  MoreListToOneSource
        if(queryWorkTaskReportStageDataListRespDto_1!= null && !CollectionUtil.isEmpty(queryWorkTaskReportStageDataListRespDto_1.getCycleStageDataList()) ){
          for (CycleStageDataDto cycleStageDataDto : queryWorkTaskReportStageDataListRespDto_1.getCycleStageDataList()) {
              BffCycleStageDataDto retElm = new BffCycleStageDataDto();
             if(queryWorkTaskReportStageDataListRespDto_1!=null){
      retElm.setCycleStageDataId(cycleStageDataDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:418154_2
retElm.setTextSummaryData(cycleStageDataDto.getTextSummaryData());//SimpleFieldAssign//sourceId:418155_2
retElm.setDataResultId(cycleStageDataDto.getDataResultId());//SimpleFieldAssign//sourceId:418156_2
retElm.setDataResult(cycleStageDataDto.getDataResult());//SimpleFieldAssign//sourceId:418157_2
retElm.setUnit(cycleStageDataDto.getUnit());//SimpleFieldAssign//sourceId:418158_2
retElm.setFilledByInductionId(cycleStageDataDto.getFilledByInductionId());//SimpleFieldAssign//sourceId:418212_2
retElm.setOperationInductionId(cycleStageDataDto.getOperationInductionId());//SimpleFieldAssign//sourceId:418159_2
retElm.setOperateTime(cycleStageDataDto.getOperateTime());//SimpleFieldAssign//sourceId:418160_2
    }
              retData.getCycleStageDataList().add(retElm);
               if(batchQueryInductionRecordListComRespDto_1!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_1.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(cycleStageDataDto.getFilledByInductionId())) {
                 if(batchQueryInductionRecordListComRespDto_1!=null){
      retElm.setFilledByUserFace(perOrgInductionRecordDto.getUserFace());//SimpleFieldAssign//sourceId:418210_2
retElm.setFilledByIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:418208_2
retElm.setFilledByNickName(perOrgInductionRecordDto.getNickName());//SimpleFieldAssign//sourceId:418209_2
retElm.setFilledByDeptShortName(perOrgInductionRecordDto.getDeptShortName());//SimpleFieldAssign//sourceId:418211_2
    }
                }
            }
          }

 if(batchQueryInductionRecordListComRespDto_3!= null){
          for (PerOrgInductionRecordDto perOrgInductionRecordDto : batchQueryInductionRecordListComRespDto_3.getPerOrgInductionRecordList()) {
                if (perOrgInductionRecordDto.getInductionRecordId().equals(cycleStageDataDto.getOperationInductionId())) {
                 if(batchQueryInductionRecordListComRespDto_3!=null){
      retElm.setOperationUserFace(perOrgInductionRecordDto.getUserFace());//SimpleFieldAssign//sourceId:418180_2
retElm.setOperationIdCardName(perOrgInductionRecordDto.getIdCardName());//SimpleFieldAssign//sourceId:418181_2
retElm.setOperationNickName(perOrgInductionRecordDto.getNickName());//SimpleFieldAssign//sourceId:418182_2
retElm.setOperationDeptShortName(perOrgInductionRecordDto.getDeptShortName());//SimpleFieldAssign//sourceId:418207_2
    }
                }
            }
          }

          }
        }//sourceId:2001913_1
if(queryWorkTaskReportStageDataListRespDto_1!=null){
      retData.setDataListAllPathList(queryWorkTaskReportStageDataListRespDto_1.getDataListAllPathList().stream().map(item -> BeanUtil.toBean(item, BffDataListAllPathDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2002391_1
    }

        List<TreeNode> nodeList = new ArrayList<>();
        // TODO: 2022/10/6 晓东，AB树，对接
        for(BffCycleStageDataDto main :retData.getCycleStageDataList()){
            TreeNode node = new TreeNode();
            node.setNLevel(1L);
            node.setSelf(main);
            nodeList.add(node);
            for(BffDataListAllPathDto sub : retData.getDataListAllPathList()){
                if(sub.getCycleStageDataId().equals(main.getCycleStageDataId())){
                    TreeNode subNode = new TreeNode();
                    subNode.setNLevel(2L);
                    subNode.setSelf(sub);
                    node.getChildrenList().add(subNode);
                }
            }
        }




        retData.setTreeNode(nodeList);
        retData.setCycleStageDataList(null);
        retData.setDataListAllPathList(null);



return retData;
  }
/**
   * B3查询工作任务汇报资料详情[10227]
   * gen by moon at 9/15/2024, 12:23:38 PM
   */
    @Trace(operationName = "B3查询工作任务汇报资料详情")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Override
  public BffQueryWorkTaskReportStageDataDetailRespDto queryWorkTaskReportStageDataDetail(BffQueryWorkTaskReportStageDataDetailReqDto reqDto){


       QueryWorkTaskReportStageDataDetailRespDto queryWorkTaskReportStageDataDetailRespDto_1 =null;
QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto_1 =null;
//步骤0: D3查询工作任务汇报资料详情 - queryWorkTaskReportStageDataDetail
     QueryWorkTaskReportStageDataDetailRespDto queryWorkTaskReportStageDataDetailRespDto = null;
    QueryWorkTaskReportStageDataDetailReqDto queryWorkTaskReportStageDataDetailReqDto=new QueryWorkTaskReportStageDataDetailReqDto();
  if(reqDto!=null){
      queryWorkTaskReportStageDataDetailReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:2002030_1
    }

    /*D3查询工作任务汇报资料详情[10226]   */
    Assert.isNull(queryWorkTaskReportStageDataDetailReqDto.getCycleStageDataId(),"B3查询工作任务汇报资料详情-D3查询工作任务汇报资料详情-周期阶段资料记录ID不能为空",false);
      queryWorkTaskReportStageDataDetailRespDto = fwAppWorkTasksClient.queryWorkTaskReportStageDataDetail(queryWorkTaskReportStageDataDetailReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryWorkTaskReportStageDataDetailRespDto_1 = queryWorkTaskReportStageDataDetailRespDto;

//步骤1: D3查询独立任务详情(公共) - queryIndependentTaskDetailCom
     QueryIndependentTaskDetailComRespDto queryIndependentTaskDetailComRespDto = null;
    if(queryWorkTaskReportStageDataDetailRespDto !=null){
          QueryIndependentTaskDetailComReqDto queryIndependentTaskDetailComReqDto=new QueryIndependentTaskDetailComReqDto();
  queryIndependentTaskDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2002098_1
queryIndependentTaskDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2002042_1
if(queryWorkTaskReportStageDataDetailRespDto!=null){
      queryIndependentTaskDetailComReqDto.setTaskId(queryWorkTaskReportStageDataDetailRespDto.getCycleDataObjId());//SimpleFieldAssign//sourceId:2002040_1
    }

    /*D3查询独立任务详情(公共)[7793]   */
    Assert.isNull(queryIndependentTaskDetailComReqDto.getTaskId(),"B3查询工作任务汇报资料详情-D3查询独立任务详情(公共)-任务ID不能为空",false);
Assert.isNull(queryIndependentTaskDetailComReqDto.getSubjectLifeCycle(),"B3查询工作任务汇报资料详情-D3查询独立任务详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryIndependentTaskDetailComReqDto.getSpaceId(),"B3查询工作任务汇报资料详情-D3查询独立任务详情(公共)-创建于空间ID不能为空",false);
      queryIndependentTaskDetailComRespDto = fwAppWorkTasksClient.queryIndependentTaskDetailCom(queryIndependentTaskDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryIndependentTaskDetailComRespDto_1 = queryIndependentTaskDetailComRespDto;
           }

BffQueryWorkTaskReportStageDataDetailRespDto retData = new BffQueryWorkTaskReportStageDataDetailRespDto();
  if(queryWorkTaskReportStageDataDetailRespDto_1!=null){
      retData.setCycleStageDataId(queryWorkTaskReportStageDataDetailRespDto_1.getCycleStageDataId());//SimpleFieldAssign//sourceId:2002108_1
retData.setTextSummaryData(queryWorkTaskReportStageDataDetailRespDto_1.getTextSummaryData());//SimpleFieldAssign//sourceId:2002110_1
retData.setHypertextContent(queryWorkTaskReportStageDataDetailRespDto_1.getHypertextContent());//SimpleFieldAssign//sourceId:2002111_1
retData.setCycleId(queryWorkTaskReportStageDataDetailRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:2002112_1
retData.setCycleStandardName(queryWorkTaskReportStageDataDetailRespDto_1.getCycleStandardName());//SimpleFieldAssign//sourceId:2002113_1
retData.setDataResultId(queryWorkTaskReportStageDataDetailRespDto_1.getDataResultId());//SimpleFieldAssign//sourceId:2002114_1
retData.setDataResult(queryWorkTaskReportStageDataDetailRespDto_1.getDataResult());//SimpleFieldAssign//sourceId:2002115_1
retData.setUnit(queryWorkTaskReportStageDataDetailRespDto_1.getUnit());//SimpleFieldAssign//sourceId:2002116_1
    }
if(queryIndependentTaskDetailComRespDto_1!=null){
      retData.setTaskId(queryIndependentTaskDetailComRespDto_1.getTaskId());//SimpleFieldAssign//sourceId:2002117_1
retData.setTaskNumber(queryIndependentTaskDetailComRespDto_1.getTaskNumber());//SimpleFieldAssign//sourceId:2002118_1
retData.setTaskName(queryIndependentTaskDetailComRespDto_1.getTaskName());//SimpleFieldAssign//sourceId:2002119_1
    }




return retData;
  }
  //
}
